home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / Movies.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  78.8 KB  |  2,331 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Movies.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Movies;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __MOVIES__}
  27. {$SETC __MOVIES__ := 1}
  28.  
  29. {$I+}
  30. {$SETC MoviesIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __QUICKDRAW__}
  35. {$I Quickdraw.p}
  36. {$ENDC}
  37. {    Types.p                                                        }
  38. {        ConditionalMacros.p                                        }
  39. {    MixedMode.p                                                    }
  40. {    QuickdrawText.p                                                }
  41.  
  42. {$IFC UNDEFINED __ALIASES__}
  43. {$I Aliases.p}
  44. {$ENDC}
  45. {    AppleTalk.p                                                    }
  46. {        OSUtils.p                                                }
  47. {            Memory.p                                            }
  48. {    Files.p                                                        }
  49.  
  50. {$IFC UNDEFINED __EVENTS__}
  51. {$I Events.p}
  52. {$ENDC}
  53.  
  54. {$IFC UNDEFINED __MENUS__}
  55. {$I Menus.p}
  56. {$ENDC}
  57.  
  58. {$IFC UNDEFINED __COMPONENTS__}
  59. {$I Components.p}
  60. {$ENDC}
  61.  
  62. {$IFC UNDEFINED __IMAGECOMPRESSION__}
  63. {$I ImageCompression.p}
  64. {$ENDC}
  65. {    QDOffscreen.p                                                }
  66. {        Errors.p                                                }
  67. {    Windows.p                                                    }
  68. {        Controls.p                                                }
  69. {    StandardFile.p                                                }
  70. {        Dialogs.p                                                }
  71. {            TextEdit.p                                            }
  72.  
  73. {$PUSH}
  74. {$ALIGN MAC68K}
  75. {$LibExport+}
  76.  
  77. CONST
  78.     MovieFileType                = 'MooV';
  79.  
  80.     MediaHandlerType            = 'mhlr';
  81.     DataHandlerType                = 'dhlr';
  82.  
  83.     VideoMediaType                = 'vide';
  84.     SoundMediaType                = 'soun';
  85.     TextMediaType                = 'text';
  86.     BaseMediaType                = 'gnrc';
  87.     MPEGMediaType                = 'MPEG';
  88.     MusicMediaType                = 'musi';
  89.     TimeCodeMediaType            = 'tmcd';
  90.     HandleDataHandlerSubType    = 'hndl';
  91.  
  92.     VisualMediaCharacteristic    = 'eyes';
  93.     AudioMediaCharacteristic    = 'ears';
  94.  
  95.     DoTheRightThing                = 0;
  96.  
  97.  
  98. TYPE
  99.     MovieRecord = RECORD
  100.         data:                    ARRAY [0..0] OF LONGINT;
  101.     END;
  102.     Movie = ^MovieRecord;
  103.  
  104.     TrackRecord = RECORD
  105.         data:                    ARRAY [0..0] OF LONGINT;
  106.     END;
  107.     Track = ^TrackRecord;
  108.  
  109.     MediaRecord = RECORD
  110.         data:                    ARRAY [0..0] OF LONGINT;
  111.     END;
  112.     Media = ^MediaRecord;
  113.  
  114.     UserDataRecord = RECORD
  115.         data:                    ARRAY [0..0] OF LONGINT;
  116.     END;
  117.     UserData = ^UserDataRecord;
  118.  
  119.     TrackEditStateRecord = RECORD
  120.         data:                    ARRAY [0..0] OF LONGINT;
  121.     END;
  122.     TrackEditState = ^TrackEditStateRecord;
  123.  
  124.     MovieEditStateRecord = RECORD
  125.         data:                    ARRAY [0..0] OF LONGINT;
  126.     END;
  127.     MovieEditState = ^MovieEditStateRecord;
  128.  
  129.     SampleDescription = RECORD
  130.         descSize:                LONGINT;
  131.         dataFormat:                LONGINT;
  132.         resvd1:                    LONGINT;
  133.         resvd2:                    INTEGER;
  134.         dataRefIndex:            INTEGER;
  135.     END;
  136.     SampleDescriptionPtr = ^SampleDescription;
  137.     SampleDescriptionHandle = ^SampleDescriptionPtr;
  138.  
  139.     SoundDescription = RECORD
  140.         descSize:                LONGINT;                                { total size of SoundDescription including extra data }
  141.         dataFormat:                LONGINT;                                {  }
  142.         resvd1:                    LONGINT;                                { reserved for apple use }
  143.         resvd2:                    INTEGER;
  144.         dataRefIndex:            INTEGER;
  145.         version:                INTEGER;                                { which version is this data }
  146.         revlevel:                INTEGER;                                { what version of that codec did this }
  147.         vendor:                    LONGINT;                                { whose  codec compressed this data }
  148.         numChannels:            INTEGER;                                { number of channels of sound }
  149.         sampleSize:                INTEGER;                                { number of bits per sample }
  150.         compressionID:            INTEGER;                                { sound compression used, 0 if none }
  151.         packetSize:                INTEGER;                                { packet size for compression, 0 if no compression }
  152.         sampleRate:                Fixed;                                    { sample rate sound is captured at }
  153.     END;
  154.     SoundDescriptionPtr = ^SoundDescription;
  155.     SoundDescriptionHandle = ^SoundDescriptionPtr;
  156.  
  157.     TextDescription = RECORD
  158.         descSize:                LONGINT;                                { Total size of TextDescription}
  159.         dataFormat:                LONGINT;                                { 'text'}
  160.         resvd1:                    LONGINT;
  161.         resvd2:                    INTEGER;
  162.         dataRefIndex:            INTEGER;
  163.         displayFlags:            LONGINT;                                { see enum below for flag values}
  164.         textJustification:        LONGINT;                                { Can be: teCenter,teFlush -Default,-Right,-Left}
  165.         bgColor:                RGBColor;                                { Background color}
  166.         defaultTextBox:            Rect;                                    { Location to place the text within the track bounds}
  167.         defaultStyle:            ScrpSTElement;                            { Default style (struct defined in TextEdit.h)}
  168.         defaultFontName:        PACKED ARRAY [0..0] OF CHAR;            { Font Name (pascal string - struct extended to fit) }
  169.     END;
  170.     TextDescriptionPtr = ^TextDescription;
  171.     TextDescriptionHandle = ^TextDescriptionPtr;
  172.  
  173. {--------------------------
  174.   Music Sample Description
  175. --------------------------}
  176.     MusicDescription = RECORD
  177.         descSize:                LONGINT;
  178.         dataFormat:                LONGINT;                                { 'musi' }
  179.         resvd1:                    LONGINT;
  180.         resvd2:                    INTEGER;
  181.         dataRefIndex:            INTEGER;
  182.         musicFlags:                LONGINT;
  183.         headerData:                ARRAY [0..0] OF LONGINT;                { variable size! }
  184.     END;
  185.     MusicDescriptionPtr = ^MusicDescription;
  186.  
  187.     MusicDescriptionHandle = ^MusicDescriptionPtr;
  188.  
  189.  
  190. CONST
  191.     dfDontDisplay                = 1 * (2**(0));                    { Don't display the text}
  192.     dfDontAutoScale                = 1 * (2**(1));                    { Don't scale text as track bounds grows or shrinks}
  193.     dfClipToTextBox                = 1 * (2**(2));                    { Clip update to the textbox}
  194.     dfUseMovieBGColor            = 1 * (2**(3));                    { Set text background to movie's background color}
  195.     dfShrinkTextBoxToFit        = 1 * (2**(4));                    { Compute minimum box to fit the sample}
  196.     dfScrollIn                    = 1 * (2**(5));                    { Scroll text in until last of text is in view }
  197.     dfScrollOut                    = 1 * (2**(6));                    { Scroll text out until last of text is gone (if both set, scroll in then out)}
  198.     dfHorizScroll                = 1 * (2**(7));                    { Scroll text horizontally (otherwise it's vertical)}
  199.     dfReverseScroll                = 1 * (2**(8));                    { vert: scroll down rather than up; horiz: scroll backwards (justfication dependent)}
  200.     dfContinuousScroll            = 1 * (2**(9));                    { new samples cause previous samples to scroll out }
  201.     dfFlowHoriz                    = 1 * (2**(10));                { horiz scroll text flows in textbox rather than extend to right }
  202.     dfDropShadow                = 1 * (2**(12));                { display text with a drop shadow }
  203.     dfAntiAlias                    = 1 * (2**(13));                { attempt to display text anti aliased}
  204.     dfKeyedText                    = 1 * (2**(14));                { key the text over background}
  205.     dfInverseHilite                = 1 * (2**(15));                { Use inverse hiliting rather than using hilite color}
  206.  
  207.     searchTextDontGoToFoundTime    = 1 * (2**(16));
  208.     searchTextDontHiliteFoundText = 1 * (2**(17));
  209.     searchTextOneTrackOnly        = 1 * (2**(18));
  210.     searchTextEnabledTracksOnly    = 1 * (2**(19));
  211.  
  212. { progress messages }
  213.     movieProgressOpen            = 0;
  214.     movieProgressUpdatePercent    = 1;
  215.     movieProgressClose            = 2;
  216.  
  217. { progress operations }
  218.     progressOpFlatten            = 1;
  219.     progressOpInsertTrackSegment = 2;
  220.     progressOpInsertMovieSegment = 3;
  221.     progressOpPaste                = 4;
  222.     progressOpAddMovieSelection    = 5;
  223.     progressOpCopy                = 6;
  224.     progressOpCut                = 7;
  225.     progressOpLoadMovieIntoRam    = 8;
  226.     progressOpLoadTrackIntoRam    = 9;
  227.     progressOpLoadMediaIntoRam    = 10;
  228.     progressOpImportMovie        = 11;
  229.     progressOpExportMovie        = 12;
  230.  
  231.     mediaQualityDraft            = $0000;
  232.     mediaQualityNormal            = $0040;
  233.     mediaQualityBetter            = $0080;
  234.     mediaQualityBest            = $00C0;
  235.  
  236. TYPE
  237.     MovieRgnCoverProcPtr = ProcPtr;  { FUNCTION MovieRgnCover(theMovie: Movie; changedRgn: RgnHandle; refcon: LONGINT): OSErr; }
  238.     MovieProgressProcPtr = ProcPtr;  { FUNCTION MovieProgress(theMovie: Movie; message: INTEGER; whatOperation: INTEGER; percentDone: Fixed; refcon: LONGINT): OSErr; }
  239.     MovieDrawingCompleteProcPtr = ProcPtr;  { FUNCTION MovieDrawingComplete(theMovie: Movie; refCon: LONGINT): OSErr; }
  240.     TrackTransferProcPtr = ProcPtr;  { FUNCTION TrackTransfer(t: Track; refCon: LONGINT): OSErr; }
  241.     GetMovieProcPtr = ProcPtr;  { FUNCTION GetMovie(offset: LONGINT; size: LONGINT; dataPtr: UNIV Ptr; refCon: UNIV Ptr): OSErr; }
  242.     MoviePreviewCallOutProcPtr = ProcPtr;  { FUNCTION MoviePreviewCallOut(refcon: LONGINT): BOOLEAN; }
  243.     MoviesErrorProcPtr = ProcPtr;  { PROCEDURE MoviesError(theErr: OSErr; refcon: LONGINT); }
  244.     TextMediaProcPtr = ProcPtr;  { FUNCTION TextMedia(theText: Handle; theMovie: Movie; VAR displayFlag: INTEGER; refcon: LONGINT): OSErr; }
  245.     MovieRgnCoverUPP = UniversalProcPtr;
  246.     MovieProgressUPP = UniversalProcPtr;
  247.     MovieDrawingCompleteUPP = UniversalProcPtr;
  248.     TrackTransferUPP = UniversalProcPtr;
  249.     GetMovieUPP = UniversalProcPtr;
  250.     MoviePreviewCallOutUPP = UniversalProcPtr;
  251.     MoviesErrorUPP = UniversalProcPtr;
  252.     TextMediaUPP = UniversalProcPtr;
  253.  
  254.     MediaHandler = ComponentInstance;
  255.     DataHandler = ComponentInstance;
  256.  
  257.     MediaHandlerComponent = Component;
  258.     DataHandlerComponent = Component;
  259.  
  260.     HandlerError = ComponentResult;
  261.  
  262.     TimeValue = LONGINT;
  263.  
  264.     TimeScale = LONGINT;
  265.  
  266.     CompTimeValue = wide;
  267.  
  268.  
  269. CONST
  270.     loopTimeBase                = 1;
  271.     palindromeLoopTimeBase        = 2;
  272.     maintainTimeBaseZero        = 4;
  273.  
  274.     
  275. TYPE
  276.     TimeBaseFlags = LONGINT;
  277.  
  278.     TimeBaseRecord = RECORD
  279.         data:                    ARRAY [0..0] OF LONGINT;
  280.     END;
  281.     TimeBase = ^TimeBaseRecord;
  282.  
  283.     CallBackRecord = RECORD
  284.         data:                    ARRAY [0..0] OF LONGINT;
  285.     END;
  286.     QTCallBack = ^CallBackRecord;
  287.  
  288.     TimeRecord = RECORD
  289.         value:                    CompTimeValue;                            { units }
  290.         scale:                    TimeScale;                                { units per second }
  291.         base:                    TimeBase;
  292.     END;
  293. { CallBack equates }
  294.  
  295. CONST
  296.     triggerTimeFwd                = $0001;                        { when curTime exceeds triggerTime going forward }
  297.     triggerTimeBwd                = $0002;                        { when curTime exceeds triggerTime going backwards }
  298.     triggerTimeEither            = $0003;                        { when curTime exceeds triggerTime going either direction }
  299.     triggerRateLT                = $0004;                        { when rate changes to less than trigger value }
  300.     triggerRateGT                = $0008;                        { when rate changes to greater than trigger value }
  301.     triggerRateEqual            = $0010;                        { when rate changes to equal trigger value }
  302.     triggerRateLTE                = triggerRateLT + triggerRateEqual;
  303.     triggerRateGTE                = triggerRateGT + triggerRateEqual;
  304.     triggerRateNotEqual            = triggerRateGT + triggerRateEqual + triggerRateLT;
  305.     triggerRateChange            = 0;
  306.     triggerAtStart                = $0001;
  307.     triggerAtStop                = $0002;
  308.  
  309.     
  310. TYPE
  311.     QTCallBackFlags = INTEGER;
  312.  
  313.  
  314. CONST
  315.     timeBaseBeforeStartTime        = 1;
  316.     timeBaseAfterStopTime        = 2;
  317.  
  318.     
  319. TYPE
  320.     TimeBaseStatus = LONGINT;
  321.  
  322.  
  323. CONST
  324.     callBackAtTime                = 1;
  325.     callBackAtRate                = 2;
  326.     callBackAtTimeJump            = 3;
  327.     callBackAtExtremes            = 4;
  328.     callBackAtInterrupt            = $8000;
  329.     callBackAtDeferredTask        = $4000;
  330.  
  331.     
  332. TYPE
  333.     QTCallBackType = INTEGER;
  334.  
  335.     QTCallBackProcPtr = ProcPtr;  { PROCEDURE QTCallBack(cb: QTCallBack; refCon: LONGINT); }
  336.     QTCallBackUPP = UniversalProcPtr;
  337.  
  338.  
  339. CONST
  340.     qtcbNeedsRateChanges        = 1;                            { wants to know about rate changes }
  341.     qtcbNeedsTimeChanges        = 2;                            { wants to know about time changes }
  342.     qtcbNeedsStartStopChanges    = 4;                            { wants to know when TimeBase start/stop is changed}
  343.  
  344.  
  345. TYPE
  346.     QTCallBackHeader = RECORD
  347.         callBackFlags:            LONGINT;
  348.         reserved1:                LONGINT;
  349.         qtPrivate:                ARRAY [0..39] OF SInt8;
  350.     END;
  351.     QTSyncTaskProcPtr = ProcPtr;  { PROCEDURE QTSyncTask(task: UNIV Ptr); }
  352.     QTSyncTaskUPP = UniversalProcPtr;
  353.  
  354.     QTSyncTaskRecord = RECORD
  355.         qLink:                    Ptr;
  356.         proc:                    QTSyncTaskUPP;
  357.     END;
  358.     QTSyncTaskPtr = ^QTSyncTaskRecord;
  359.  
  360.  
  361. CONST
  362.     keepInRam                    = 1 * (2**(0));                    { load and make non-purgable}
  363.     unkeepInRam                    = 1 * (2**(1));                    { mark as purgable}
  364.     flushFromRam                = 1 * (2**(2));                    { empty those handles}
  365.     loadForwardTrackEdits        = 1 * (2**(3));                    {    load track edits into ram for playing forward}
  366.     loadBackwardTrackEdits        = 1 * (2**(4));                    {    load track edits into ram for playing in reverse}
  367.  
  368.     newMovieActive                = 1 * (2**(0));
  369.     newMovieDontResolveDataRefs    = 1 * (2**(1));
  370.     newMovieDontAskUnresolvedDataRefs = 1 * (2**(2));
  371.     newMovieDontAutoAlternates    = 1 * (2**(3));
  372.  
  373. { track usage bits }
  374.     trackUsageInMovie            = 1 * (2**(1));
  375.     trackUsageInPreview            = 1 * (2**(2));
  376.     trackUsageInPoster            = 1 * (2**(3));
  377.  
  378. { Add/GetMediaSample flags }
  379.     mediaSampleNotSync            = 1 * (2**(0));                    { sample is not a sync sample (eg. is frame differenced }
  380.     mediaSampleShadowSync        = 1 * (2**(1));                    { sample is a shadow sync }
  381.  
  382.     pasteInParallel                = 1;
  383.     showUserSettingsDialog        = 2;
  384.     movieToFileOnlyExport        = 4;
  385.  
  386.     nextTimeMediaSample            = 1 * (2**(0));
  387.     nextTimeMediaEdit            = 1 * (2**(1));
  388.     nextTimeTrackEdit            = 1 * (2**(2));
  389.     nextTimeSyncSample            = 1 * (2**(3));
  390.     nextTimeEdgeOK                = 1 * (2**(14));
  391.     nextTimeIgnoreActiveSegment    = 1 * (2**(15));
  392.  
  393.     
  394. TYPE
  395.     nextTimeFlagsEnum = INTEGER;
  396.  
  397.  
  398. CONST
  399.     createMovieFileDeleteCurFile = 1 * (2**(31));
  400.     createMovieFileDontCreateMovie = 1 * (2**(30));
  401.     createMovieFileDontOpenFile    = 1 * (2**(29));
  402.  
  403.     
  404. TYPE
  405.     createMovieFileFlagsEnum = LONGINT;
  406.  
  407.  
  408. CONST
  409.     flattenAddMovieToDataFork    = 1 * (2**(0));
  410.     flattenActiveTracksOnly        = 1 * (2**(2));
  411.     flattenDontInterleaveFlatten = 1 * (2**(3));
  412.  
  413.     
  414. TYPE
  415.     movieFlattenFlagsEnum = LONGINT;
  416.  
  417.  
  418. CONST
  419.     movieInDataForkResID        = -1;                            { magic res ID }
  420.  
  421.     mcTopLeftMovie                = 1 * (2**(0));                    { usually centered }
  422.     mcScaleMovieToFit            = 1 * (2**(1));                    { usually only scales down }
  423.     mcWithBadge                    = 1 * (2**(2));                    { give me a badge }
  424.     mcNotVisible                = 1 * (2**(3));                    { don't show controller }
  425.     mcWithFrame                    = 1 * (2**(4));                    { gimme a frame }
  426.  
  427.     movieScrapDontZeroScrap        = 1 * (2**(0));
  428.     movieScrapOnlyPutMovie        = 1 * (2**(1));
  429.  
  430.     dataRefSelfReference        = 1 * (2**(0));
  431.     dataRefWasNotResolved        = 1 * (2**(1));
  432.  
  433.     
  434. TYPE
  435.     dataRefAttributesFlags = LONGINT;
  436.  
  437.  
  438. CONST
  439.     hintsScrubMode                = 1 * (2**(0));                    { mask == && (if flags == scrub on, flags != scrub off) }
  440.     hintsLoop                    = 1 * (2**(1));
  441.     hintsDontPurge                = 1 * (2**(2));
  442.     hintsUseScreenBuffer        = 1 * (2**(5));
  443.     hintsAllowInterlace            = 1 * (2**(6));
  444.     hintsUseSoundInterp            = 1 * (2**(7));
  445.     hintsHighQuality            = 1 * (2**(8));                    { slooooow }
  446.     hintsPalindrome                = 1 * (2**(9));
  447.     hintsInactive                = 1 * (2**(11));
  448.  
  449.     
  450. TYPE
  451.     playHintsEnum = LONGINT;
  452.  
  453.  
  454. CONST
  455.     mediaHandlerFlagBaseClient    = 1;
  456.  
  457.     
  458. TYPE
  459.     mediaHandlerFlagsEnum = LONGINT;
  460.  
  461.  
  462. CONST
  463.     movieTrackMediaType            = 1 * (2**(0));
  464.     movieTrackCharacteristic    = 1 * (2**(1));
  465.     movieTrackEnabledOnly        = 1 * (2**(2));
  466.  
  467.  
  468. TYPE
  469.     SampleReferenceRecord = RECORD
  470.         dataOffset:                LONGINT;
  471.         dataSize:                LONGINT;
  472.         durationPerSample:        TimeValue;
  473.         numberOfSamples:        LONGINT;
  474.         sampleFlags:            INTEGER;
  475.     END;
  476.     SampleReferencePtr = ^SampleReferenceRecord;
  477.  
  478. {************************
  479. * Initialization Routines 
  480. *************************}
  481.  
  482. FUNCTION EnterMovies: OSErr;
  483.     {$IFC NOT GENERATINGCFM}
  484.     INLINE $7001, $AAAA;
  485.     {$ENDC}
  486. PROCEDURE ExitMovies;
  487.     {$IFC NOT GENERATINGCFM}
  488.     INLINE $7002, $AAAA;
  489.     {$ENDC}
  490. {************************
  491. * Error Routines 
  492. *************************}
  493. FUNCTION GetMoviesError: OSErr;
  494.     {$IFC NOT GENERATINGCFM}
  495.     INLINE $7003, $AAAA;
  496.     {$ENDC}
  497. PROCEDURE ClearMoviesStickyError;
  498.     {$IFC NOT GENERATINGCFM}
  499.     INLINE $303C, $DE, $AAAA;
  500.     {$ENDC}
  501. FUNCTION GetMoviesStickyError: OSErr;
  502.     {$IFC NOT GENERATINGCFM}
  503.     INLINE $7004, $AAAA;
  504.     {$ENDC}
  505. PROCEDURE SetMoviesErrorProc(errProc: MoviesErrorUPP; refcon: LONGINT);
  506.     {$IFC NOT GENERATINGCFM}
  507.     INLINE $303C, $EF, $AAAA;
  508.     {$ENDC}
  509. {************************
  510. * Idle Routines 
  511. *************************}
  512. PROCEDURE MoviesTask(theMovie: Movie; maxMilliSecToUse: LONGINT);
  513.     {$IFC NOT GENERATINGCFM}
  514.     INLINE $7005, $AAAA;
  515.     {$ENDC}
  516. FUNCTION PrerollMovie(theMovie: Movie; time: TimeValue; Rate: Fixed): OSErr;
  517.     {$IFC NOT GENERATINGCFM}
  518.     INLINE $7006, $AAAA;
  519.     {$ENDC}
  520. FUNCTION LoadMovieIntoRam(theMovie: Movie; time: TimeValue; duration: TimeValue; flags: LONGINT): OSErr;
  521.     {$IFC NOT GENERATINGCFM}
  522.     INLINE $7007, $AAAA;
  523.     {$ENDC}
  524. FUNCTION LoadTrackIntoRam(theTrack: Track; time: TimeValue; duration: TimeValue; flags: LONGINT): OSErr;
  525.     {$IFC NOT GENERATINGCFM}
  526.     INLINE $303C, $16E, $AAAA;
  527.     {$ENDC}
  528. FUNCTION LoadMediaIntoRam(theMedia: Media; time: TimeValue; duration: TimeValue; flags: LONGINT): OSErr;
  529.     {$IFC NOT GENERATINGCFM}
  530.     INLINE $7008, $AAAA;
  531.     {$ENDC}
  532. PROCEDURE SetMovieActive(theMovie: Movie; active: BOOLEAN);
  533.     {$IFC NOT GENERATINGCFM}
  534.     INLINE $7009, $AAAA;
  535.     {$ENDC}
  536. FUNCTION GetMovieActive(theMovie: Movie): BOOLEAN;
  537.     {$IFC NOT GENERATINGCFM}
  538.     INLINE $700A, $AAAA;
  539.     {$ENDC}
  540. {************************
  541. * calls for playing movies, previews, posters
  542. *************************}
  543. PROCEDURE StartMovie(theMovie: Movie);
  544.     {$IFC NOT GENERATINGCFM}
  545.     INLINE $700B, $AAAA;
  546.     {$ENDC}
  547. PROCEDURE StopMovie(theMovie: Movie);
  548.     {$IFC NOT GENERATINGCFM}
  549.     INLINE $700C, $AAAA;
  550.     {$ENDC}
  551. PROCEDURE GoToBeginningOfMovie(theMovie: Movie);
  552.     {$IFC NOT GENERATINGCFM}
  553.     INLINE $700D, $AAAA;
  554.     {$ENDC}
  555. PROCEDURE GoToEndOfMovie(theMovie: Movie);
  556.     {$IFC NOT GENERATINGCFM}
  557.     INLINE $700E, $AAAA;
  558.     {$ENDC}
  559. FUNCTION IsMovieDone(theMovie: Movie): BOOLEAN;
  560.     {$IFC NOT GENERATINGCFM}
  561.     INLINE $303C, $DD, $AAAA;
  562.     {$ENDC}
  563. FUNCTION GetMoviePreviewMode(theMovie: Movie): BOOLEAN;
  564.     {$IFC NOT GENERATINGCFM}
  565.     INLINE $700F, $AAAA;
  566.     {$ENDC}
  567. PROCEDURE SetMoviePreviewMode(theMovie: Movie; usePreview: BOOLEAN);
  568.     {$IFC NOT GENERATINGCFM}
  569.     INLINE $7010, $AAAA;
  570.     {$ENDC}
  571. PROCEDURE ShowMoviePoster(theMovie: Movie);
  572.     {$IFC NOT GENERATINGCFM}
  573.     INLINE $7011, $AAAA;
  574.     {$ENDC}
  575. PROCEDURE PlayMoviePreview(theMovie: Movie; callOutProc: MoviePreviewCallOutUPP; refcon: LONGINT);
  576.     {$IFC NOT GENERATINGCFM}
  577.     INLINE $303C, $F2, $AAAA;
  578.     {$ENDC}
  579. {************************
  580. * calls for controlling movies & tracks which are playing
  581. *************************}
  582. FUNCTION GetMovieTimeBase(theMovie: Movie): TimeBase;
  583.     {$IFC NOT GENERATINGCFM}
  584.     INLINE $7012, $AAAA;
  585.     {$ENDC}
  586. PROCEDURE SetMovieMasterTimeBase(theMovie: Movie; tb: TimeBase; {CONST}VAR slaveZero: TimeRecord);
  587.     {$IFC NOT GENERATINGCFM}
  588.     INLINE $303C, $167, $AAAA;
  589.     {$ENDC}
  590. PROCEDURE SetMovieMasterClock(theMovie: Movie; clockMeister: Component; {CONST}VAR slaveZero: TimeRecord);
  591.     {$IFC NOT GENERATINGCFM}
  592.     INLINE $303C, $168, $AAAA;
  593.     {$ENDC}
  594. PROCEDURE GetMovieGWorld(theMovie: Movie; VAR port: CGrafPtr; VAR gdh: GDHandle);
  595.     {$IFC NOT GENERATINGCFM}
  596.     INLINE $7015, $AAAA;
  597.     {$ENDC}
  598. PROCEDURE SetMovieGWorld(theMovie: Movie; port: CGrafPtr; gdh: GDHandle);
  599.     {$IFC NOT GENERATINGCFM}
  600.     INLINE $7016, $AAAA;
  601.     {$ENDC}
  602.  
  603. CONST
  604.     movieDrawingCallWhenChanged    = 0;
  605.     movieDrawingCallAlways        = 1;
  606.  
  607.  
  608. PROCEDURE SetMovieDrawingCompleteProc(theMovie: Movie; flags: LONGINT; proc: MovieDrawingCompleteUPP; refCon: LONGINT);
  609.     {$IFC NOT GENERATINGCFM}
  610.     INLINE $303C, $1DE, $AAAA;
  611.     {$ENDC}
  612. FUNCTION GetNextTrackForCompositing(theMovie: Movie; theTrack: Track): Track;
  613.     {$IFC NOT GENERATINGCFM}
  614.     INLINE $303C, $1FA, $AAAA;
  615.     {$ENDC}
  616. FUNCTION GetPrevTrackForCompositing(theMovie: Movie; theTrack: Track): Track;
  617.     {$IFC NOT GENERATINGCFM}
  618.     INLINE $303C, $1FB, $AAAA;
  619.     {$ENDC}
  620. PROCEDURE SetTrackGWorld(theTrack: Track; port: CGrafPtr; gdh: GDHandle; proc: TrackTransferUPP; refCon: LONGINT);
  621.     {$IFC NOT GENERATINGCFM}
  622.     INLINE $303C, $9D, $AAAA;
  623.     {$ENDC}
  624. FUNCTION GetMoviePict(theMovie: Movie; time: TimeValue): PicHandle;
  625.     {$IFC NOT GENERATINGCFM}
  626.     INLINE $701D, $AAAA;
  627.     {$ENDC}
  628. FUNCTION GetTrackPict(theTrack: Track; time: TimeValue): PicHandle;
  629.     {$IFC NOT GENERATINGCFM}
  630.     INLINE $701E, $AAAA;
  631.     {$ENDC}
  632. FUNCTION GetMoviePosterPict(theMovie: Movie): PicHandle;
  633.     {$IFC NOT GENERATINGCFM}
  634.     INLINE $303C, $F7, $AAAA;
  635.     {$ENDC}
  636. { called between Begin & EndUpdate }
  637. FUNCTION UpdateMovie(theMovie: Movie): OSErr;
  638.     {$IFC NOT GENERATINGCFM}
  639.     INLINE $701F, $AAAA;
  640.     {$ENDC}
  641. {*** spatial movie routines ***}
  642. PROCEDURE GetMovieBox(theMovie: Movie; VAR boxRect: Rect);
  643.     {$IFC NOT GENERATINGCFM}
  644.     INLINE $303C, $F9, $AAAA;
  645.     {$ENDC}
  646. PROCEDURE SetMovieBox(theMovie: Movie; {CONST}VAR boxRect: Rect);
  647.     {$IFC NOT GENERATINGCFM}
  648.     INLINE $303C, $FA, $AAAA;
  649.     {$ENDC}
  650. {* movie display clip }
  651. FUNCTION GetMovieDisplayClipRgn(theMovie: Movie): RgnHandle;
  652.     {$IFC NOT GENERATINGCFM}
  653.     INLINE $303C, $FC, $AAAA;
  654.     {$ENDC}
  655. PROCEDURE SetMovieDisplayClipRgn(theMovie: Movie; theClip: RgnHandle);
  656.     {$IFC NOT GENERATINGCFM}
  657.     INLINE $303C, $FD, $AAAA;
  658.     {$ENDC}
  659. {* movie src clip }
  660. FUNCTION GetMovieClipRgn(theMovie: Movie): RgnHandle;
  661.     {$IFC NOT GENERATINGCFM}
  662.     INLINE $303C, $100, $AAAA;
  663.     {$ENDC}
  664. PROCEDURE SetMovieClipRgn(theMovie: Movie; theClip: RgnHandle);
  665.     {$IFC NOT GENERATINGCFM}
  666.     INLINE $303C, $101, $AAAA;
  667.     {$ENDC}
  668. {* track src clip }
  669. FUNCTION GetTrackClipRgn(theTrack: Track): RgnHandle;
  670.     {$IFC NOT GENERATINGCFM}
  671.     INLINE $303C, $102, $AAAA;
  672.     {$ENDC}
  673. PROCEDURE SetTrackClipRgn(theTrack: Track; theClip: RgnHandle);
  674.     {$IFC NOT GENERATINGCFM}
  675.     INLINE $303C, $103, $AAAA;
  676.     {$ENDC}
  677. {* bounds in display space (not clipped by display clip) }
  678. FUNCTION GetMovieDisplayBoundsRgn(theMovie: Movie): RgnHandle;
  679.     {$IFC NOT GENERATINGCFM}
  680.     INLINE $303C, $FB, $AAAA;
  681.     {$ENDC}
  682. FUNCTION GetTrackDisplayBoundsRgn(theTrack: Track): RgnHandle;
  683.     {$IFC NOT GENERATINGCFM}
  684.     INLINE $303C, $112, $AAAA;
  685.     {$ENDC}
  686. {* bounds in movie space }
  687. FUNCTION GetMovieBoundsRgn(theMovie: Movie): RgnHandle;
  688.     {$IFC NOT GENERATINGCFM}
  689.     INLINE $303C, $FE, $AAAA;
  690.     {$ENDC}
  691. FUNCTION GetTrackMovieBoundsRgn(theTrack: Track): RgnHandle;
  692.     {$IFC NOT GENERATINGCFM}
  693.     INLINE $303C, $FF, $AAAA;
  694.     {$ENDC}
  695. {* bounds in track space }
  696. FUNCTION GetTrackBoundsRgn(theTrack: Track): RgnHandle;
  697.     {$IFC NOT GENERATINGCFM}
  698.     INLINE $303C, $111, $AAAA;
  699.     {$ENDC}
  700. {* mattes - always in track space }
  701. FUNCTION GetTrackMatte(theTrack: Track): PixMapHandle;
  702.     {$IFC NOT GENERATINGCFM}
  703.     INLINE $303C, $115, $AAAA;
  704.     {$ENDC}
  705. PROCEDURE SetTrackMatte(theTrack: Track; theMatte: PixMapHandle);
  706.     {$IFC NOT GENERATINGCFM}
  707.     INLINE $303C, $116, $AAAA;
  708.     {$ENDC}
  709. PROCEDURE DisposeMatte(theMatte: PixMapHandle);
  710.     {$IFC NOT GENERATINGCFM}
  711.     INLINE $303C, $14A, $AAAA;
  712.     {$ENDC}
  713. {************************
  714. * calls for getting/saving movies
  715. *************************}
  716. FUNCTION NewMovie(flags: LONGINT): Movie;
  717.     {$IFC NOT GENERATINGCFM}
  718.     INLINE $303C, $187, $AAAA;
  719.     {$ENDC}
  720. FUNCTION PutMovieIntoHandle(theMovie: Movie; publicMovie: Handle): OSErr;
  721.     {$IFC NOT GENERATINGCFM}
  722.     INLINE $7022, $AAAA;
  723.     {$ENDC}
  724. FUNCTION PutMovieIntoDataFork(theMovie: Movie; fRefNum: INTEGER; offset: LONGINT; maxSize: LONGINT): OSErr;
  725.     {$IFC NOT GENERATINGCFM}
  726.     INLINE $303C, $1B4, $AAAA;
  727.     {$ENDC}
  728. PROCEDURE DisposeMovie(theMovie: Movie);
  729.     {$IFC NOT GENERATINGCFM}
  730.     INLINE $7023, $AAAA;
  731.     {$ENDC}
  732. {************************
  733. * Movie State Routines
  734. *************************}
  735. FUNCTION GetMovieCreationTime(theMovie: Movie): LONGINT;
  736.     {$IFC NOT GENERATINGCFM}
  737.     INLINE $7026, $AAAA;
  738.     {$ENDC}
  739. FUNCTION GetMovieModificationTime(theMovie: Movie): LONGINT;
  740.     {$IFC NOT GENERATINGCFM}
  741.     INLINE $7027, $AAAA;
  742.     {$ENDC}
  743. FUNCTION GetMovieTimeScale(theMovie: Movie): TimeScale;
  744.     {$IFC NOT GENERATINGCFM}
  745.     INLINE $7029, $AAAA;
  746.     {$ENDC}
  747. PROCEDURE SetMovieTimeScale(theMovie: Movie; timeScale: TimeScale);
  748.     {$IFC NOT GENERATINGCFM}
  749.     INLINE $702A, $AAAA;
  750.     {$ENDC}
  751. FUNCTION GetMovieDuration(theMovie: Movie): TimeValue;
  752.     {$IFC NOT GENERATINGCFM}
  753.     INLINE $702B, $AAAA;
  754.     {$ENDC}
  755. FUNCTION GetMovieRate(theMovie: Movie): Fixed;
  756.     {$IFC NOT GENERATINGCFM}
  757.     INLINE $702C, $AAAA;
  758.     {$ENDC}
  759. PROCEDURE SetMovieRate(theMovie: Movie; rate: Fixed);
  760.     {$IFC NOT GENERATINGCFM}
  761.     INLINE $702D, $AAAA;
  762.     {$ENDC}
  763. FUNCTION GetMoviePreferredRate(theMovie: Movie): Fixed;
  764.     {$IFC NOT GENERATINGCFM}
  765.     INLINE $303C, $F3, $AAAA;
  766.     {$ENDC}
  767. PROCEDURE SetMoviePreferredRate(theMovie: Movie; rate: Fixed);
  768.     {$IFC NOT GENERATINGCFM}
  769.     INLINE $303C, $F4, $AAAA;
  770.     {$ENDC}
  771. FUNCTION GetMoviePreferredVolume(theMovie: Movie): INTEGER;
  772.     {$IFC NOT GENERATINGCFM}
  773.     INLINE $303C, $F5, $AAAA;
  774.     {$ENDC}
  775. PROCEDURE SetMoviePreferredVolume(theMovie: Movie; volume: INTEGER);
  776.     {$IFC NOT GENERATINGCFM}
  777.     INLINE $303C, $F6, $AAAA;
  778.     {$ENDC}
  779. FUNCTION GetMovieVolume(theMovie: Movie): INTEGER;
  780.     {$IFC NOT GENERATINGCFM}
  781.     INLINE $702E, $AAAA;
  782.     {$ENDC}
  783. PROCEDURE SetMovieVolume(theMovie: Movie; volume: INTEGER);
  784.     {$IFC NOT GENERATINGCFM}
  785.     INLINE $702F, $AAAA;
  786.     {$ENDC}
  787. PROCEDURE GetMovieMatrix(theMovie: Movie; VAR matrix: MatrixRecord);
  788.     {$IFC NOT GENERATINGCFM}
  789.     INLINE $7031, $AAAA;
  790.     {$ENDC}
  791. PROCEDURE SetMovieMatrix(theMovie: Movie; {CONST}VAR matrix: MatrixRecord);
  792.     {$IFC NOT GENERATINGCFM}
  793.     INLINE $7032, $AAAA;
  794.     {$ENDC}
  795. PROCEDURE GetMoviePreviewTime(theMovie: Movie; VAR previewTime: TimeValue; VAR previewDuration: TimeValue);
  796.     {$IFC NOT GENERATINGCFM}
  797.     INLINE $7033, $AAAA;
  798.     {$ENDC}
  799. PROCEDURE SetMoviePreviewTime(theMovie: Movie; previewTime: TimeValue; previewDuration: TimeValue);
  800.     {$IFC NOT GENERATINGCFM}
  801.     INLINE $7034, $AAAA;
  802.     {$ENDC}
  803. FUNCTION GetMoviePosterTime(theMovie: Movie): TimeValue;
  804.     {$IFC NOT GENERATINGCFM}
  805.     INLINE $7035, $AAAA;
  806.     {$ENDC}
  807. PROCEDURE SetMoviePosterTime(theMovie: Movie; posterTime: TimeValue);
  808.     {$IFC NOT GENERATINGCFM}
  809.     INLINE $7036, $AAAA;
  810.     {$ENDC}
  811. PROCEDURE GetMovieSelection(theMovie: Movie; VAR selectionTime: TimeValue; VAR selectionDuration: TimeValue);
  812.     {$IFC NOT GENERATINGCFM}
  813.     INLINE $7037, $AAAA;
  814.     {$ENDC}
  815. PROCEDURE SetMovieSelection(theMovie: Movie; selectionTime: TimeValue; selectionDuration: TimeValue);
  816.     {$IFC NOT GENERATINGCFM}
  817.     INLINE $7038, $AAAA;
  818.     {$ENDC}
  819. PROCEDURE SetMovieActiveSegment(theMovie: Movie; startTime: TimeValue; duration: TimeValue);
  820.     {$IFC NOT GENERATINGCFM}
  821.     INLINE $303C, $15C, $AAAA;
  822.     {$ENDC}
  823. PROCEDURE GetMovieActiveSegment(theMovie: Movie; VAR startTime: TimeValue; VAR duration: TimeValue);
  824.     {$IFC NOT GENERATINGCFM}
  825.     INLINE $303C, $15D, $AAAA;
  826.     {$ENDC}
  827. FUNCTION GetMovieTime(theMovie: Movie; VAR currentTime: TimeRecord): TimeValue;
  828.     {$IFC NOT GENERATINGCFM}
  829.     INLINE $7039, $AAAA;
  830.     {$ENDC}
  831. PROCEDURE SetMovieTime(theMovie: Movie; {CONST}VAR newtime: TimeRecord);
  832.     {$IFC NOT GENERATINGCFM}
  833.     INLINE $703C, $AAAA;
  834.     {$ENDC}
  835. PROCEDURE SetMovieTimeValue(theMovie: Movie; newtime: TimeValue);
  836.     {$IFC NOT GENERATINGCFM}
  837.     INLINE $703D, $AAAA;
  838.     {$ENDC}
  839. FUNCTION GetMovieUserData(theMovie: Movie): UserData;
  840.     {$IFC NOT GENERATINGCFM}
  841.     INLINE $703E, $AAAA;
  842.     {$ENDC}
  843. {************************
  844. * Track/Media finding routines
  845. *************************}
  846. FUNCTION GetMovieTrackCount(theMovie: Movie): LONGINT;
  847.     {$IFC NOT GENERATINGCFM}
  848.     INLINE $703F, $AAAA;
  849.     {$ENDC}
  850. FUNCTION GetMovieTrack(theMovie: Movie; trackID: LONGINT): Track;
  851.     {$IFC NOT GENERATINGCFM}
  852.     INLINE $7040, $AAAA;
  853.     {$ENDC}
  854. FUNCTION GetMovieIndTrack(theMovie: Movie; index: LONGINT): Track;
  855.     {$IFC NOT GENERATINGCFM}
  856.     INLINE $303C, $117, $AAAA;
  857.     {$ENDC}
  858. FUNCTION GetMovieIndTrackType(theMovie: Movie; index: LONGINT; trackType: OSType; flags: LONGINT): Track;
  859.     {$IFC NOT GENERATINGCFM}
  860.     INLINE $303C, $208, $AAAA;
  861.     {$ENDC}
  862. FUNCTION GetTrackID(theTrack: Track): LONGINT;
  863.     {$IFC NOT GENERATINGCFM}
  864.     INLINE $303C, $127, $AAAA;
  865.     {$ENDC}
  866. FUNCTION GetTrackMovie(theTrack: Track): Movie;
  867.     {$IFC NOT GENERATINGCFM}
  868.     INLINE $303C, $D0, $AAAA;
  869.     {$ENDC}
  870. {************************
  871. * Track creation routines
  872. *************************}
  873. FUNCTION NewMovieTrack(theMovie: Movie; width: Fixed; height: Fixed; trackVolume: INTEGER): Track;
  874.     {$IFC NOT GENERATINGCFM}
  875.     INLINE $303C, $188, $AAAA;
  876.     {$ENDC}
  877. PROCEDURE DisposeMovieTrack(theTrack: Track);
  878.     {$IFC NOT GENERATINGCFM}
  879.     INLINE $7042, $AAAA;
  880.     {$ENDC}
  881. {************************
  882. * Track State routines
  883. *************************}
  884. FUNCTION GetTrackCreationTime(theTrack: Track): LONGINT;
  885.     {$IFC NOT GENERATINGCFM}
  886.     INLINE $7043, $AAAA;
  887.     {$ENDC}
  888. FUNCTION GetTrackModificationTime(theTrack: Track): LONGINT;
  889.     {$IFC NOT GENERATINGCFM}
  890.     INLINE $7044, $AAAA;
  891.     {$ENDC}
  892. FUNCTION GetTrackEnabled(theTrack: Track): BOOLEAN;
  893.     {$IFC NOT GENERATINGCFM}
  894.     INLINE $7045, $AAAA;
  895.     {$ENDC}
  896. PROCEDURE SetTrackEnabled(theTrack: Track; isEnabled: BOOLEAN);
  897.     {$IFC NOT GENERATINGCFM}
  898.     INLINE $7046, $AAAA;
  899.     {$ENDC}
  900. FUNCTION GetTrackUsage(theTrack: Track): LONGINT;
  901.     {$IFC NOT GENERATINGCFM}
  902.     INLINE $7047, $AAAA;
  903.     {$ENDC}
  904. PROCEDURE SetTrackUsage(theTrack: Track; usage: LONGINT);
  905.     {$IFC NOT GENERATINGCFM}
  906.     INLINE $7048, $AAAA;
  907.     {$ENDC}
  908. FUNCTION GetTrackDuration(theTrack: Track): TimeValue;
  909.     {$IFC NOT GENERATINGCFM}
  910.     INLINE $704B, $AAAA;
  911.     {$ENDC}
  912. FUNCTION GetTrackOffset(theTrack: Track): TimeValue;
  913.     {$IFC NOT GENERATINGCFM}
  914.     INLINE $704C, $AAAA;
  915.     {$ENDC}
  916. PROCEDURE SetTrackOffset(theTrack: Track; movieOffsetTime: TimeValue);
  917.     {$IFC NOT GENERATINGCFM}
  918.     INLINE $704D, $AAAA;
  919.     {$ENDC}
  920. FUNCTION GetTrackLayer(theTrack: Track): INTEGER;
  921.     {$IFC NOT GENERATINGCFM}
  922.     INLINE $7050, $AAAA;
  923.     {$ENDC}
  924. PROCEDURE SetTrackLayer(theTrack: Track; layer: INTEGER);
  925.     {$IFC NOT GENERATINGCFM}
  926.     INLINE $7051, $AAAA;
  927.     {$ENDC}
  928. FUNCTION GetTrackAlternate(theTrack: Track): Track;
  929.     {$IFC NOT GENERATINGCFM}
  930.     INLINE $7052, $AAAA;
  931.     {$ENDC}
  932. PROCEDURE SetTrackAlternate(theTrack: Track; alternateT: Track);
  933.     {$IFC NOT GENERATINGCFM}
  934.     INLINE $7053, $AAAA;
  935.     {$ENDC}
  936. PROCEDURE SetAutoTrackAlternatesEnabled(theMovie: Movie; enable: BOOLEAN);
  937.     {$IFC NOT GENERATINGCFM}
  938.     INLINE $303C, $15E, $AAAA;
  939.     {$ENDC}
  940. PROCEDURE SelectMovieAlternates(theMovie: Movie);
  941.     {$IFC NOT GENERATINGCFM}
  942.     INLINE $303C, $15F, $AAAA;
  943.     {$ENDC}
  944. FUNCTION GetTrackVolume(theTrack: Track): INTEGER;
  945.     {$IFC NOT GENERATINGCFM}
  946.     INLINE $7054, $AAAA;
  947.     {$ENDC}
  948. PROCEDURE SetTrackVolume(theTrack: Track; volume: INTEGER);
  949.     {$IFC NOT GENERATINGCFM}
  950.     INLINE $7055, $AAAA;
  951.     {$ENDC}
  952. PROCEDURE GetTrackMatrix(theTrack: Track; VAR matrix: MatrixRecord);
  953.     {$IFC NOT GENERATINGCFM}
  954.     INLINE $7056, $AAAA;
  955.     {$ENDC}
  956. PROCEDURE SetTrackMatrix(theTrack: Track; {CONST}VAR matrix: MatrixRecord);
  957.     {$IFC NOT GENERATINGCFM}
  958.     INLINE $7057, $AAAA;
  959.     {$ENDC}
  960. PROCEDURE GetTrackDimensions(theTrack: Track; VAR width: Fixed; VAR height: Fixed);
  961.     {$IFC NOT GENERATINGCFM}
  962.     INLINE $705D, $AAAA;
  963.     {$ENDC}
  964. PROCEDURE SetTrackDimensions(theTrack: Track; width: Fixed; height: Fixed);
  965.     {$IFC NOT GENERATINGCFM}
  966.     INLINE $705E, $AAAA;
  967.     {$ENDC}
  968. FUNCTION GetTrackUserData(theTrack: Track): UserData;
  969.     {$IFC NOT GENERATINGCFM}
  970.     INLINE $705F, $AAAA;
  971.     {$ENDC}
  972. {************************
  973. * get Media routines
  974. *************************}
  975. FUNCTION NewTrackMedia(theTrack: Track; mediaType: OSType; timeScale: TimeScale; dataRef: Handle; dataRefType: OSType): Media;
  976.     {$IFC NOT GENERATINGCFM}
  977.     INLINE $303C, $18E, $AAAA;
  978.     {$ENDC}
  979. PROCEDURE DisposeTrackMedia(theMedia: Media);
  980.     {$IFC NOT GENERATINGCFM}
  981.     INLINE $7061, $AAAA;
  982.     {$ENDC}
  983. FUNCTION GetTrackMedia(theTrack: Track): Media;
  984.     {$IFC NOT GENERATINGCFM}
  985.     INLINE $7062, $AAAA;
  986.     {$ENDC}
  987. FUNCTION GetMediaTrack(theMedia: Media): Track;
  988.     {$IFC NOT GENERATINGCFM}
  989.     INLINE $303C, $C5, $AAAA;
  990.     {$ENDC}
  991. {************************
  992. * Media State routines
  993. *************************}
  994. FUNCTION GetMediaCreationTime(theMedia: Media): LONGINT;
  995.     {$IFC NOT GENERATINGCFM}
  996.     INLINE $7066, $AAAA;
  997.     {$ENDC}
  998. FUNCTION GetMediaModificationTime(theMedia: Media): LONGINT;
  999.     {$IFC NOT GENERATINGCFM}
  1000.     INLINE $7067, $AAAA;
  1001.     {$ENDC}
  1002. FUNCTION GetMediaTimeScale(theMedia: Media): TimeScale;
  1003.     {$IFC NOT GENERATINGCFM}
  1004.     INLINE $7068, $AAAA;
  1005.     {$ENDC}
  1006. PROCEDURE SetMediaTimeScale(theMedia: Media; timeScale: TimeScale);
  1007.     {$IFC NOT GENERATINGCFM}
  1008.     INLINE $7069, $AAAA;
  1009.     {$ENDC}
  1010. FUNCTION GetMediaDuration(theMedia: Media): TimeValue;
  1011.     {$IFC NOT GENERATINGCFM}
  1012.     INLINE $706A, $AAAA;
  1013.     {$ENDC}
  1014. FUNCTION GetMediaLanguage(theMedia: Media): INTEGER;
  1015.     {$IFC NOT GENERATINGCFM}
  1016.     INLINE $706B, $AAAA;
  1017.     {$ENDC}
  1018. PROCEDURE SetMediaLanguage(theMedia: Media; language: INTEGER);
  1019.     {$IFC NOT GENERATINGCFM}
  1020.     INLINE $706C, $AAAA;
  1021.     {$ENDC}
  1022. FUNCTION GetMediaQuality(theMedia: Media): INTEGER;
  1023.     {$IFC NOT GENERATINGCFM}
  1024.     INLINE $706D, $AAAA;
  1025.     {$ENDC}
  1026. PROCEDURE SetMediaQuality(theMedia: Media; quality: INTEGER);
  1027.     {$IFC NOT GENERATINGCFM}
  1028.     INLINE $706E, $AAAA;
  1029.     {$ENDC}
  1030. PROCEDURE GetMediaHandlerDescription(theMedia: Media; VAR mediaType: OSType; VAR creatorName: Str255; VAR creatorManufacturer: OSType);
  1031.     {$IFC NOT GENERATINGCFM}
  1032.     INLINE $706F, $AAAA;
  1033.     {$ENDC}
  1034. FUNCTION GetMediaUserData(theMedia: Media): UserData;
  1035.     {$IFC NOT GENERATINGCFM}
  1036.     INLINE $7070, $AAAA;
  1037.     {$ENDC}
  1038. {************************
  1039. * Media Handler routines
  1040. *************************}
  1041. FUNCTION GetMediaHandler(theMedia: Media): MediaHandler;
  1042.     {$IFC NOT GENERATINGCFM}
  1043.     INLINE $7071, $AAAA;
  1044.     {$ENDC}
  1045. FUNCTION SetMediaHandler(theMedia: Media; mH: MediaHandlerComponent): OSErr;
  1046.     {$IFC NOT GENERATINGCFM}
  1047.     INLINE $303C, $190, $AAAA;
  1048.     {$ENDC}
  1049. {************************
  1050. * Media's Data routines
  1051. *************************}
  1052. FUNCTION BeginMediaEdits(theMedia: Media): OSErr;
  1053.     {$IFC NOT GENERATINGCFM}
  1054.     INLINE $7072, $AAAA;
  1055.     {$ENDC}
  1056. FUNCTION EndMediaEdits(theMedia: Media): OSErr;
  1057.     {$IFC NOT GENERATINGCFM}
  1058.     INLINE $7073, $AAAA;
  1059.     {$ENDC}
  1060. FUNCTION SetMediaDefaultDataRefIndex(theMedia: Media; index: INTEGER): OSErr;
  1061.     {$IFC NOT GENERATINGCFM}
  1062.     INLINE $303C, $1E0, $AAAA;
  1063.     {$ENDC}
  1064. PROCEDURE GetMediaDataHandlerDescription(theMedia: Media; index: INTEGER; VAR dhType: OSType; VAR creatorName: Str255; VAR creatorManufacturer: OSType);
  1065.     {$IFC NOT GENERATINGCFM}
  1066.     INLINE $303C, $19E, $AAAA;
  1067.     {$ENDC}
  1068. FUNCTION GetMediaDataHandler(theMedia: Media; index: INTEGER): DataHandler;
  1069.     {$IFC NOT GENERATINGCFM}
  1070.     INLINE $303C, $19F, $AAAA;
  1071.     {$ENDC}
  1072. FUNCTION SetMediaDataHandler(theMedia: Media; index: INTEGER; dataHandler: DataHandlerComponent): OSErr;
  1073.     {$IFC NOT GENERATINGCFM}
  1074.     INLINE $303C, $1A0, $AAAA;
  1075.     {$ENDC}
  1076. FUNCTION GetDataHandler(dataRef: Handle; dataHandlerSubType: OSType; flags: LONGINT): Component;
  1077.     {$IFC NOT GENERATINGCFM}
  1078.     INLINE $303C, $1ED, $AAAA;
  1079.     {$ENDC}
  1080. {************************
  1081. * Media Sample Table Routines
  1082. *************************}
  1083. FUNCTION GetMediaSampleDescriptionCount(theMedia: Media): LONGINT;
  1084.     {$IFC NOT GENERATINGCFM}
  1085.     INLINE $7077, $AAAA;
  1086.     {$ENDC}
  1087. PROCEDURE GetMediaSampleDescription(theMedia: Media; index: LONGINT; descH: SampleDescriptionHandle);
  1088.     {$IFC NOT GENERATINGCFM}
  1089.     INLINE $7078, $AAAA;
  1090.     {$ENDC}
  1091. FUNCTION SetMediaSampleDescription(theMedia: Media; index: LONGINT; descH: SampleDescriptionHandle): OSErr;
  1092.     {$IFC NOT GENERATINGCFM}
  1093.     INLINE $303C, $1D0, $AAAA;
  1094.     {$ENDC}
  1095. FUNCTION GetMediaSampleCount(theMedia: Media): LONGINT;
  1096.     {$IFC NOT GENERATINGCFM}
  1097.     INLINE $7079, $AAAA;
  1098.     {$ENDC}
  1099. PROCEDURE SampleNumToMediaTime(theMedia: Media; logicalSampleNum: LONGINT; VAR sampleTime: TimeValue; VAR sampleDuration: TimeValue);
  1100.     {$IFC NOT GENERATINGCFM}
  1101.     INLINE $707A, $AAAA;
  1102.     {$ENDC}
  1103. PROCEDURE MediaTimeToSampleNum(theMedia: Media; time: TimeValue; VAR sampleNum: LONGINT; VAR sampleTime: TimeValue; VAR sampleDuration: TimeValue);
  1104.     {$IFC NOT GENERATINGCFM}
  1105.     INLINE $707B, $AAAA;
  1106.     {$ENDC}
  1107. FUNCTION AddMediaSample(theMedia: Media; dataIn: Handle; inOffset: LONGINT; size: LONGINT; durationPerSample: TimeValue; sampleDescriptionH: SampleDescriptionHandle; numberOfSamples: LONGINT; sampleFlags: INTEGER; VAR sampleTime: TimeValue): OSErr;
  1108.     {$IFC NOT GENERATINGCFM}
  1109.     INLINE $707C, $AAAA;
  1110.     {$ENDC}
  1111. FUNCTION AddMediaSampleReference(theMedia: Media; dataOffset: LONGINT; size: LONGINT; durationPerSample: TimeValue; sampleDescriptionH: SampleDescriptionHandle; numberOfSamples: LONGINT; sampleFlags: INTEGER; VAR sampleTime: TimeValue): OSErr;
  1112.     {$IFC NOT GENERATINGCFM}
  1113.     INLINE $707D, $AAAA;
  1114.     {$ENDC}
  1115. FUNCTION AddMediaSampleReferences(theMedia: Media; sampleDescriptionH: SampleDescriptionHandle; numberOfSamples: LONGINT; sampleRefs: SampleReferencePtr; VAR sampleTime: TimeValue): OSErr;
  1116.     {$IFC NOT GENERATINGCFM}
  1117.     INLINE $303C, $1F7, $AAAA;
  1118.     {$ENDC}
  1119. FUNCTION GetMediaSample(theMedia: Media; dataOut: Handle; maxSizeToGrow: LONGINT; VAR size: LONGINT; time: TimeValue; VAR sampleTime: TimeValue; VAR durationPerSample: TimeValue; sampleDescriptionH: SampleDescriptionHandle; VAR sampleDescriptionIndex: LONGINT; maxNumberOfSamples: LONGINT; VAR numberOfSamples: LONGINT; VAR sampleFlags: INTEGER): OSErr;
  1120.     {$IFC NOT GENERATINGCFM}
  1121.     INLINE $707E, $AAAA;
  1122.     {$ENDC}
  1123. FUNCTION GetMediaSampleReference(theMedia: Media; VAR dataOffset: LONGINT; VAR size: LONGINT; time: TimeValue; VAR sampleTime: TimeValue; VAR durationPerSample: TimeValue; sampleDescriptionH: SampleDescriptionHandle; VAR sampleDescriptionIndex: LONGINT; maxNumberOfSamples: LONGINT; VAR numberOfSamples: LONGINT; VAR sampleFlags: INTEGER): OSErr;
  1124.     {$IFC NOT GENERATINGCFM}
  1125.     INLINE $707F, $AAAA;
  1126.     {$ENDC}
  1127. FUNCTION SetMediaPreferredChunkSize(theMedia: Media; maxChunkSize: LONGINT): OSErr;
  1128.     {$IFC NOT GENERATINGCFM}
  1129.     INLINE $303C, $1F8, $AAAA;
  1130.     {$ENDC}
  1131. FUNCTION GetMediaPreferredChunkSize(theMedia: Media; VAR maxChunkSize: LONGINT): OSErr;
  1132.     {$IFC NOT GENERATINGCFM}
  1133.     INLINE $303C, $1F9, $AAAA;
  1134.     {$ENDC}
  1135. FUNCTION SetMediaShadowSync(theMedia: Media; frameDiffSampleNum: LONGINT; syncSampleNum: LONGINT): OSErr;
  1136.     {$IFC NOT GENERATINGCFM}
  1137.     INLINE $303C, $121, $AAAA;
  1138.     {$ENDC}
  1139. FUNCTION GetMediaShadowSync(theMedia: Media; frameDiffSampleNum: LONGINT; VAR syncSampleNum: LONGINT): OSErr;
  1140.     {$IFC NOT GENERATINGCFM}
  1141.     INLINE $303C, $122, $AAAA;
  1142.     {$ENDC}
  1143. {************************
  1144. * Editing Routines
  1145. *************************}
  1146. FUNCTION InsertMediaIntoTrack(theTrack: Track; trackStart: TimeValue; mediaTime: TimeValue; mediaDuration: TimeValue; mediaRate: Fixed): OSErr;
  1147.     {$IFC NOT GENERATINGCFM}
  1148.     INLINE $303C, $183, $AAAA;
  1149.     {$ENDC}
  1150. FUNCTION InsertTrackSegment(srcTrack: Track; dstTrack: Track; srcIn: TimeValue; srcDuration: TimeValue; dstIn: TimeValue): OSErr;
  1151.     {$IFC NOT GENERATINGCFM}
  1152.     INLINE $303C, $85, $AAAA;
  1153.     {$ENDC}
  1154. FUNCTION InsertMovieSegment(srcMovie: Movie; dstMovie: Movie; srcIn: TimeValue; srcDuration: TimeValue; dstIn: TimeValue): OSErr;
  1155.     {$IFC NOT GENERATINGCFM}
  1156.     INLINE $303C, $86, $AAAA;
  1157.     {$ENDC}
  1158. FUNCTION InsertEmptyTrackSegment(dstTrack: Track; dstIn: TimeValue; dstDuration: TimeValue): OSErr;
  1159.     {$IFC NOT GENERATINGCFM}
  1160.     INLINE $303C, $87, $AAAA;
  1161.     {$ENDC}
  1162. FUNCTION InsertEmptyMovieSegment(dstMovie: Movie; dstIn: TimeValue; dstDuration: TimeValue): OSErr;
  1163.     {$IFC NOT GENERATINGCFM}
  1164.     INLINE $303C, $88, $AAAA;
  1165.     {$ENDC}
  1166. FUNCTION DeleteTrackSegment(theTrack: Track; startTime: TimeValue; duration: TimeValue): OSErr;
  1167.     {$IFC NOT GENERATINGCFM}
  1168.     INLINE $303C, $89, $AAAA;
  1169.     {$ENDC}
  1170. FUNCTION DeleteMovieSegment(theMovie: Movie; startTime: TimeValue; duration: TimeValue): OSErr;
  1171.     {$IFC NOT GENERATINGCFM}
  1172.     INLINE $303C, $8A, $AAAA;
  1173.     {$ENDC}
  1174. FUNCTION ScaleTrackSegment(theTrack: Track; startTime: TimeValue; oldDuration: TimeValue; newDuration: TimeValue): OSErr;
  1175.     {$IFC NOT GENERATINGCFM}
  1176.     INLINE $303C, $8B, $AAAA;
  1177.     {$ENDC}
  1178. FUNCTION ScaleMovieSegment(theMovie: Movie; startTime: TimeValue; oldDuration: TimeValue; newDuration: TimeValue): OSErr;
  1179.     {$IFC NOT GENERATINGCFM}
  1180.     INLINE $303C, $8C, $AAAA;
  1181.     {$ENDC}
  1182. {************************
  1183. * Hi-level Editing Routines
  1184. *************************}
  1185. FUNCTION CutMovieSelection(theMovie: Movie): Movie;
  1186.     {$IFC NOT GENERATINGCFM}
  1187.     INLINE $303C, $8D, $AAAA;
  1188.     {$ENDC}
  1189. FUNCTION CopyMovieSelection(theMovie: Movie): Movie;
  1190.     {$IFC NOT GENERATINGCFM}
  1191.     INLINE $303C, $8E, $AAAA;
  1192.     {$ENDC}
  1193. PROCEDURE PasteMovieSelection(theMovie: Movie; src: Movie);
  1194.     {$IFC NOT GENERATINGCFM}
  1195.     INLINE $303C, $8F, $AAAA;
  1196.     {$ENDC}
  1197. PROCEDURE AddMovieSelection(theMovie: Movie; src: Movie);
  1198.     {$IFC NOT GENERATINGCFM}
  1199.     INLINE $303C, $152, $AAAA;
  1200.     {$ENDC}
  1201. PROCEDURE ClearMovieSelection(theMovie: Movie);
  1202.     {$IFC NOT GENERATINGCFM}
  1203.     INLINE $303C, $E1, $AAAA;
  1204.     {$ENDC}
  1205. FUNCTION PasteHandleIntoMovie(h: Handle; handleType: OSType; theMovie: Movie; flags: LONGINT; userComp: ComponentInstance): OSErr;
  1206.     {$IFC NOT GENERATINGCFM}
  1207.     INLINE $303C, $CB, $AAAA;
  1208.     {$ENDC}
  1209. FUNCTION PutMovieIntoTypedHandle(theMovie: Movie; targetTrack: Track; handleType: OSType; publicMovie: Handle; start: TimeValue; dur: TimeValue; flags: LONGINT; userComp: ComponentInstance): OSErr;
  1210.     {$IFC NOT GENERATINGCFM}
  1211.     INLINE $303C, $1CD, $AAAA;
  1212.     {$ENDC}
  1213. FUNCTION IsScrapMovie(targetTrack: Track): Component;
  1214.     {$IFC NOT GENERATINGCFM}
  1215.     INLINE $303C, $CC, $AAAA;
  1216.     {$ENDC}
  1217. {************************
  1218. * Middle-level Editing Routines
  1219. *************************}
  1220. FUNCTION CopyTrackSettings(srcTrack: Track; dstTrack: Track): OSErr;
  1221.     {$IFC NOT GENERATINGCFM}
  1222.     INLINE $303C, $153, $AAAA;
  1223.     {$ENDC}
  1224. FUNCTION CopyMovieSettings(srcMovie: Movie; dstMovie: Movie): OSErr;
  1225.     {$IFC NOT GENERATINGCFM}
  1226.     INLINE $303C, $154, $AAAA;
  1227.     {$ENDC}
  1228. FUNCTION AddEmptyTrackToMovie(srcTrack: Track; dstMovie: Movie; dataRef: Handle; dataRefType: OSType; VAR dstTrack: Track): OSErr;
  1229.     {$IFC NOT GENERATINGCFM}
  1230.     INLINE $7074, $AAAA;
  1231.     {$ENDC}
  1232. {************************
  1233. * movie & track edit state routines
  1234. *************************}
  1235. FUNCTION NewMovieEditState(theMovie: Movie): MovieEditState;
  1236.     {$IFC NOT GENERATINGCFM}
  1237.     INLINE $303C, $104, $AAAA;
  1238.     {$ENDC}
  1239. FUNCTION UseMovieEditState(theMovie: Movie; toState: MovieEditState): OSErr;
  1240.     {$IFC NOT GENERATINGCFM}
  1241.     INLINE $303C, $105, $AAAA;
  1242.     {$ENDC}
  1243. FUNCTION DisposeMovieEditState(state: MovieEditState): OSErr;
  1244.     {$IFC NOT GENERATINGCFM}
  1245.     INLINE $303C, $106, $AAAA;
  1246.     {$ENDC}
  1247. FUNCTION NewTrackEditState(theTrack: Track): TrackEditState;
  1248.     {$IFC NOT GENERATINGCFM}
  1249.     INLINE $303C, $107, $AAAA;
  1250.     {$ENDC}
  1251. FUNCTION UseTrackEditState(theTrack: Track; state: TrackEditState): OSErr;
  1252.     {$IFC NOT GENERATINGCFM}
  1253.     INLINE $303C, $108, $AAAA;
  1254.     {$ENDC}
  1255. FUNCTION DisposeTrackEditState(state: TrackEditState): OSErr;
  1256.     {$IFC NOT GENERATINGCFM}
  1257.     INLINE $303C, $109, $AAAA;
  1258.     {$ENDC}
  1259. {************************
  1260. * track reference routines
  1261. *************************}
  1262. FUNCTION AddTrackReference(theTrack: Track; refTrack: Track; refType: OSType; VAR addedIndex: LONGINT): OSErr;
  1263.     {$IFC NOT GENERATINGCFM}
  1264.     INLINE $303C, $1F0, $AAAA;
  1265.     {$ENDC}
  1266. FUNCTION DeleteTrackReference(theTrack: Track; refType: OSType; index: LONGINT): OSErr;
  1267.     {$IFC NOT GENERATINGCFM}
  1268.     INLINE $303C, $1F1, $AAAA;
  1269.     {$ENDC}
  1270. FUNCTION SetTrackReference(theTrack: Track; refTrack: Track; refType: OSType; index: LONGINT): OSErr;
  1271.     {$IFC NOT GENERATINGCFM}
  1272.     INLINE $303C, $1F2, $AAAA;
  1273.     {$ENDC}
  1274. FUNCTION GetTrackReference(theTrack: Track; refType: OSType; index: LONGINT): Track;
  1275.     {$IFC NOT GENERATINGCFM}
  1276.     INLINE $303C, $1F3, $AAAA;
  1277.     {$ENDC}
  1278. FUNCTION GetNextTrackReferenceType(theTrack: Track; refType: OSType): OSType;
  1279.     {$IFC NOT GENERATINGCFM}
  1280.     INLINE $303C, $1F4, $AAAA;
  1281.     {$ENDC}
  1282. FUNCTION GetTrackReferenceCount(theTrack: Track; refType: OSType): LONGINT;
  1283.     {$IFC NOT GENERATINGCFM}
  1284.     INLINE $303C, $1F5, $AAAA;
  1285.     {$ENDC}
  1286. {************************
  1287. * high level file conversion routines
  1288. *************************}
  1289. FUNCTION ConvertFileToMovieFile({CONST}VAR inputFile: FSSpec; {CONST}VAR outputFile: FSSpec; creator: OSType; scriptTag: ScriptCode; VAR resID: INTEGER; flags: LONGINT; userComp: ComponentInstance; proc: MovieProgressUPP; refCon: LONGINT): OSErr;
  1290.     {$IFC NOT GENERATINGCFM}
  1291.     INLINE $303C, $1CB, $AAAA;
  1292.     {$ENDC}
  1293. FUNCTION ConvertMovieToFile(theMovie: Movie; onlyTrack: Track; VAR outputFile: FSSpec; fileType: OSType; creator: OSType; scriptTag: ScriptCode; VAR resID: INTEGER; flags: LONGINT; userComp: ComponentInstance): OSErr;
  1294.     {$IFC NOT GENERATINGCFM}
  1295.     INLINE $303C, $1CC, $AAAA;
  1296.     {$ENDC}
  1297. {************************
  1298. * Movie Timebase Conversion Routines
  1299. *************************}
  1300. FUNCTION TrackTimeToMediaTime(value: TimeValue; theTrack: Track): TimeValue;
  1301.     {$IFC NOT GENERATINGCFM}
  1302.     INLINE $303C, $96, $AAAA;
  1303.     {$ENDC}
  1304. FUNCTION GetTrackEditRate(theTrack: Track; atTime: TimeValue): Fixed;
  1305.     {$IFC NOT GENERATINGCFM}
  1306.     INLINE $303C, $123, $AAAA;
  1307.     {$ENDC}
  1308. {************************
  1309. * Miscellaneous Routines
  1310. *************************}
  1311. FUNCTION GetMovieDataSize(theMovie: Movie; startTime: TimeValue; duration: TimeValue): LONGINT;
  1312.     {$IFC NOT GENERATINGCFM}
  1313.     INLINE $303C, $98, $AAAA;
  1314.     {$ENDC}
  1315. FUNCTION GetTrackDataSize(theTrack: Track; startTime: TimeValue; duration: TimeValue): LONGINT;
  1316.     {$IFC NOT GENERATINGCFM}
  1317.     INLINE $303C, $149, $AAAA;
  1318.     {$ENDC}
  1319. FUNCTION GetMediaDataSize(theMedia: Media; startTime: TimeValue; duration: TimeValue): LONGINT;
  1320.     {$IFC NOT GENERATINGCFM}
  1321.     INLINE $303C, $99, $AAAA;
  1322.     {$ENDC}
  1323. FUNCTION PtInMovie(theMovie: Movie; pt: Point): BOOLEAN;
  1324.     {$IFC NOT GENERATINGCFM}
  1325.     INLINE $303C, $9A, $AAAA;
  1326.     {$ENDC}
  1327. FUNCTION PtInTrack(theTrack: Track; pt: Point): BOOLEAN;
  1328.     {$IFC NOT GENERATINGCFM}
  1329.     INLINE $303C, $9B, $AAAA;
  1330.     {$ENDC}
  1331. {************************
  1332. * Group Selection Routines
  1333. *************************}
  1334. PROCEDURE SetMovieLanguage(theMovie: Movie; language: LONGINT);
  1335.     {$IFC NOT GENERATINGCFM}
  1336.     INLINE $303C, $9C, $AAAA;
  1337.     {$ENDC}
  1338. {************************
  1339. * User Data
  1340. *************************}
  1341. FUNCTION GetUserData(theUserData: UserData; data: Handle; udType: OSType; index: LONGINT): OSErr;
  1342.     {$IFC NOT GENERATINGCFM}
  1343.     INLINE $303C, $9E, $AAAA;
  1344.     {$ENDC}
  1345. FUNCTION AddUserData(theUserData: UserData; data: Handle; udType: OSType): OSErr;
  1346.     {$IFC NOT GENERATINGCFM}
  1347.     INLINE $303C, $9F, $AAAA;
  1348.     {$ENDC}
  1349. FUNCTION RemoveUserData(theUserData: UserData; udType: OSType; index: LONGINT): OSErr;
  1350.     {$IFC NOT GENERATINGCFM}
  1351.     INLINE $303C, $A0, $AAAA;
  1352.     {$ENDC}
  1353. FUNCTION CountUserDataType(theUserData: UserData; udType: OSType): INTEGER;
  1354.     {$IFC NOT GENERATINGCFM}
  1355.     INLINE $303C, $14B, $AAAA;
  1356.     {$ENDC}
  1357. FUNCTION GetNextUserDataType(theUserData: UserData; udType: OSType): LONGINT;
  1358.     {$IFC NOT GENERATINGCFM}
  1359.     INLINE $303C, $1A5, $AAAA;
  1360.     {$ENDC}
  1361. FUNCTION GetUserDataItem(theUserData: UserData; data: UNIV Ptr; size: LONGINT; udType: OSType; index: LONGINT): OSErr;
  1362.     {$IFC NOT GENERATINGCFM}
  1363.     INLINE $303C, $126, $AAAA;
  1364.     {$ENDC}
  1365. FUNCTION SetUserDataItem(theUserData: UserData; data: UNIV Ptr; size: LONGINT; udType: OSType; index: LONGINT): OSErr;
  1366.     {$IFC NOT GENERATINGCFM}
  1367.     INLINE $303C, $12E, $AAAA;
  1368.     {$ENDC}
  1369. FUNCTION AddUserDataText(theUserData: UserData; data: Handle; udType: OSType; index: LONGINT; itlRegionTag: INTEGER): OSErr;
  1370.     {$IFC NOT GENERATINGCFM}
  1371.     INLINE $303C, $14C, $AAAA;
  1372.     {$ENDC}
  1373. FUNCTION GetUserDataText(theUserData: UserData; data: Handle; udType: OSType; index: LONGINT; itlRegionTag: INTEGER): OSErr;
  1374.     {$IFC NOT GENERATINGCFM}
  1375.     INLINE $303C, $14D, $AAAA;
  1376.     {$ENDC}
  1377. FUNCTION RemoveUserDataText(theUserData: UserData; udType: OSType; index: LONGINT; itlRegionTag: INTEGER): OSErr;
  1378.     {$IFC NOT GENERATINGCFM}
  1379.     INLINE $303C, $14E, $AAAA;
  1380.     {$ENDC}
  1381. FUNCTION NewUserData(VAR theUserData: UserData): OSErr;
  1382.     {$IFC NOT GENERATINGCFM}
  1383.     INLINE $303C, $12F, $AAAA;
  1384.     {$ENDC}
  1385. FUNCTION DisposeUserData(theUserData: UserData): OSErr;
  1386.     {$IFC NOT GENERATINGCFM}
  1387.     INLINE $303C, $130, $AAAA;
  1388.     {$ENDC}
  1389. FUNCTION NewUserDataFromHandle(h: Handle; VAR theUserData: UserData): OSErr;
  1390.     {$IFC NOT GENERATINGCFM}
  1391.     INLINE $303C, $131, $AAAA;
  1392.     {$ENDC}
  1393. FUNCTION PutUserDataIntoHandle(theUserData: UserData; h: Handle): OSErr;
  1394.     {$IFC NOT GENERATINGCFM}
  1395.     INLINE $303C, $132, $AAAA;
  1396.     {$ENDC}
  1397. PROCEDURE GetMediaNextInterestingTime(theMedia: Media; interestingTimeFlags: INTEGER; time: TimeValue; rate: Fixed; VAR interestingTime: TimeValue; VAR interestingDuration: TimeValue);
  1398.     {$IFC NOT GENERATINGCFM}
  1399.     INLINE $303C, $16D, $AAAA;
  1400.     {$ENDC}
  1401. PROCEDURE GetTrackNextInterestingTime(theTrack: Track; interestingTimeFlags: INTEGER; time: TimeValue; rate: Fixed; VAR interestingTime: TimeValue; VAR interestingDuration: TimeValue);
  1402.     {$IFC NOT GENERATINGCFM}
  1403.     INLINE $303C, $E2, $AAAA;
  1404.     {$ENDC}
  1405. PROCEDURE GetMovieNextInterestingTime(theMovie: Movie; interestingTimeFlags: INTEGER; numMediaTypes: INTEGER; {CONST}VAR whichMediaTypes: OSType; time: TimeValue; rate: Fixed; VAR interestingTime: TimeValue; VAR interestingDuration: TimeValue);
  1406.     {$IFC NOT GENERATINGCFM}
  1407.     INLINE $303C, $10E, $AAAA;
  1408.     {$ENDC}
  1409. FUNCTION CreateMovieFile({CONST}VAR fileSpec: FSSpec; creator: OSType; scriptTag: ScriptCode; createMovieFileFlags: LONGINT; VAR resRefNum: INTEGER; VAR newmovie: Movie): OSErr;
  1410.     {$IFC NOT GENERATINGCFM}
  1411.     INLINE $303C, $191, $AAAA;
  1412.     {$ENDC}
  1413. FUNCTION OpenMovieFile({CONST}VAR fileSpec: FSSpec; VAR resRefNum: INTEGER; permission: ByteParameter): OSErr;
  1414.     {$IFC NOT GENERATINGCFM}
  1415.     INLINE $303C, $192, $AAAA;
  1416.     {$ENDC}
  1417. FUNCTION CloseMovieFile(resRefNum: INTEGER): OSErr;
  1418.     {$IFC NOT GENERATINGCFM}
  1419.     INLINE $303C, $D5, $AAAA;
  1420.     {$ENDC}
  1421. FUNCTION DeleteMovieFile({CONST}VAR fileSpec: FSSpec): OSErr;
  1422.     {$IFC NOT GENERATINGCFM}
  1423.     INLINE $303C, $175, $AAAA;
  1424.     {$ENDC}
  1425. FUNCTION NewMovieFromFile(VAR theMovie: Movie; resRefNum: INTEGER; VAR resId: INTEGER; resName: StringPtr; newMovieFlags: INTEGER; VAR dataRefWasChanged: BOOLEAN): OSErr;
  1426.     {$IFC NOT GENERATINGCFM}
  1427.     INLINE $303C, $F0, $AAAA;
  1428.     {$ENDC}
  1429. FUNCTION NewMovieFromHandle(VAR theMovie: Movie; h: Handle; newMovieFlags: INTEGER; VAR dataRefWasChanged: BOOLEAN): OSErr;
  1430.     {$IFC NOT GENERATINGCFM}
  1431.     INLINE $303C, $F1, $AAAA;
  1432.     {$ENDC}
  1433. FUNCTION NewMovieFromDataFork(VAR theMovie: Movie; fRefNum: INTEGER; fileOffset: LONGINT; newMovieFlags: INTEGER; VAR dataRefWasChanged: BOOLEAN): OSErr;
  1434.     {$IFC NOT GENERATINGCFM}
  1435.     INLINE $303C, $1B3, $AAAA;
  1436.     {$ENDC}
  1437. FUNCTION NewMovieFromUserProc(VAR m: Movie; flags: INTEGER; VAR dataRefWasChanged: BOOLEAN; getProc: GetMovieUPP; refCon: UNIV Ptr; defaultDataRef: Handle; dataRefType: OSType): OSErr;
  1438.     {$IFC NOT GENERATINGCFM}
  1439.     INLINE $303C, $1EC, $AAAA;
  1440.     {$ENDC}
  1441. FUNCTION AddMovieResource(theMovie: Movie; resRefNum: INTEGER; VAR resId: INTEGER; resName: ConstStr255Param): OSErr;
  1442.     {$IFC NOT GENERATINGCFM}
  1443.     INLINE $303C, $D7, $AAAA;
  1444.     {$ENDC}
  1445. FUNCTION UpdateMovieResource(theMovie: Movie; resRefNum: INTEGER; resId: INTEGER; resName: ConstStr255Param): OSErr;
  1446.     {$IFC NOT GENERATINGCFM}
  1447.     INLINE $303C, $D8, $AAAA;
  1448.     {$ENDC}
  1449. FUNCTION RemoveMovieResource(resRefNum: INTEGER; resId: INTEGER): OSErr;
  1450.     {$IFC NOT GENERATINGCFM}
  1451.     INLINE $303C, $176, $AAAA;
  1452.     {$ENDC}
  1453. FUNCTION HasMovieChanged(theMovie: Movie): BOOLEAN;
  1454.     {$IFC NOT GENERATINGCFM}
  1455.     INLINE $303C, $D9, $AAAA;
  1456.     {$ENDC}
  1457. PROCEDURE ClearMovieChanged(theMovie: Movie);
  1458.     {$IFC NOT GENERATINGCFM}
  1459.     INLINE $303C, $113, $AAAA;
  1460.     {$ENDC}
  1461. FUNCTION SetMovieDefaultDataRef(theMovie: Movie; dataRef: Handle; dataRefType: OSType): OSErr;
  1462.     {$IFC NOT GENERATINGCFM}
  1463.     INLINE $303C, $1C1, $AAAA;
  1464.     {$ENDC}
  1465. FUNCTION GetMovieDefaultDataRef(theMovie: Movie; VAR dataRef: Handle; VAR dataRefType: OSType): OSErr;
  1466.     {$IFC NOT GENERATINGCFM}
  1467.     INLINE $303C, $1D2, $AAAA;
  1468.     {$ENDC}
  1469. FUNCTION SetMovieColorTable(theMovie: Movie; ctab: CTabHandle): OSErr;
  1470.     {$IFC NOT GENERATINGCFM}
  1471.     INLINE $303C, $205, $AAAA;
  1472.     {$ENDC}
  1473. FUNCTION GetMovieColorTable(theMovie: Movie; VAR ctab: CTabHandle): OSErr;
  1474.     {$IFC NOT GENERATINGCFM}
  1475.     INLINE $303C, $206, $AAAA;
  1476.     {$ENDC}
  1477. PROCEDURE FlattenMovie(theMovie: Movie; movieFlattenFlags: LONGINT; {CONST}VAR theFile: FSSpec; creator: OSType; scriptTag: ScriptCode; createMovieFileFlags: LONGINT; VAR resId: INTEGER; resName: ConstStr255Param);
  1478.     {$IFC NOT GENERATINGCFM}
  1479.     INLINE $303C, $19B, $AAAA;
  1480.     {$ENDC}
  1481. FUNCTION FlattenMovieData(theMovie: Movie; movieFlattenFlags: LONGINT; {CONST}VAR theFile: FSSpec; creator: OSType; scriptTag: ScriptCode; createMovieFileFlags: LONGINT): Movie;
  1482.     {$IFC NOT GENERATINGCFM}
  1483.     INLINE $303C, $19C, $AAAA;
  1484.     {$ENDC}
  1485. PROCEDURE SetMovieProgressProc(theMovie: Movie; p: MovieProgressUPP; refcon: LONGINT);
  1486.     {$IFC NOT GENERATINGCFM}
  1487.     INLINE $303C, $19A, $AAAA;
  1488.     {$ENDC}
  1489. {************************
  1490. * Video Media routines
  1491. *************************}
  1492. FUNCTION GetVideoMediaGraphicsMode(mh: MediaHandler; VAR graphicsMode: LONGINT; VAR opColor: RGBColor): HandlerError;
  1493.     {$IFC NOT GENERATINGCFM}
  1494.     INLINE $2F3C, $8, $101, $7000, $A82A;
  1495.     {$ENDC}
  1496. FUNCTION SetVideoMediaGraphicsMode(mh: MediaHandler; graphicsMode: LONGINT; {CONST}VAR opColor: RGBColor): HandlerError;
  1497.     {$IFC NOT GENERATINGCFM}
  1498.     INLINE $2F3C, $8, $102, $7000, $A82A;
  1499.     {$ENDC}
  1500. {************************
  1501. * Sound Media routines
  1502. *************************}
  1503. FUNCTION GetSoundMediaBalance(mh: MediaHandler; VAR balance: INTEGER): HandlerError;
  1504.     {$IFC NOT GENERATINGCFM}
  1505.     INLINE $2F3C, $4, $101, $7000, $A82A;
  1506.     {$ENDC}
  1507. FUNCTION SetSoundMediaBalance(mh: MediaHandler; balance: INTEGER): HandlerError;
  1508.     {$IFC NOT GENERATINGCFM}
  1509.     INLINE $2F3C, $2, $102, $7000, $A82A;
  1510.     {$ENDC}
  1511. {************************
  1512. * Text Media routines
  1513. *************************}
  1514. { Return displayFlags for TextProc }
  1515.  
  1516. CONST
  1517.     txtProcDefaultDisplay        = 0;                            {    Use the media's default}
  1518.     txtProcDontDisplay            = 1;                            {    Don't display the text}
  1519.     txtProcDoDisplay            = 2;                            {    Do display the text}
  1520.  
  1521.  
  1522. FUNCTION SetTextProc(mh: MediaHandler; TextProc: TextMediaUPP; refcon: LONGINT): ComponentResult;
  1523.     {$IFC NOT GENERATINGCFM}
  1524.     INLINE $2F3C, $8, $101, $7000, $A82A;
  1525.     {$ENDC}
  1526. FUNCTION AddTextSample(mh: MediaHandler; text: Ptr; size: LONGINT; fontNumber: INTEGER; fontSize: INTEGER; textFace: Style; VAR textColor: RGBColor; VAR backColor: RGBColor; textJustification: INTEGER; VAR textBox: Rect; displayFlags: LONGINT; scrollDelay: TimeValue; hiliteStart: INTEGER; hiliteEnd: INTEGER; VAR rgbHiliteColor: RGBColor; duration: TimeValue; VAR sampleTime: TimeValue): ComponentResult;
  1527.     {$IFC NOT GENERATINGCFM}
  1528.     INLINE $2F3C, $34, $102, $7000, $A82A;
  1529.     {$ENDC}
  1530. FUNCTION AddTESample(mh: MediaHandler; hTE: TEHandle; VAR backColor: RGBColor; textJustification: INTEGER; VAR textBox: Rect; displayFlags: LONGINT; scrollDelay: TimeValue; hiliteStart: INTEGER; hiliteEnd: INTEGER; VAR rgbHiliteColor: RGBColor; duration: TimeValue; VAR sampleTime: TimeValue): ComponentResult;
  1531.     {$IFC NOT GENERATINGCFM}
  1532.     INLINE $2F3C, $26, $103, $7000, $A82A;
  1533.     {$ENDC}
  1534. FUNCTION AddHiliteSample(mh: MediaHandler; hiliteStart: INTEGER; hiliteEnd: INTEGER; VAR rgbHiliteColor: RGBColor; duration: TimeValue; VAR sampleTime: TimeValue): ComponentResult;
  1535.     {$IFC NOT GENERATINGCFM}
  1536.     INLINE $2F3C, $10, $104, $7000, $A82A;
  1537.     {$ENDC}
  1538.  
  1539. CONST
  1540.     findTextEdgeOK                = 1 * (2**(0));                    { Okay to find text at specified sample time}
  1541.     findTextCaseSensitive        = 1 * (2**(1));                    { Case sensitive search}
  1542.     findTextReverseSearch        = 1 * (2**(2));                    { Search from sampleTime backwards}
  1543.     findTextWrapAround            = 1 * (2**(3));                    { Wrap search when beginning or end of movie is hit}
  1544.     findTextUseOffset            = 1 * (2**(4));                    { Begin search at the given character offset into sample rather than edge}
  1545.  
  1546.  
  1547. FUNCTION FindNextText(mh: MediaHandler; text: Ptr; size: LONGINT; findFlags: INTEGER; startTime: TimeValue; VAR foundTime: TimeValue; VAR foundDuration: TimeValue; VAR offset: LONGINT): ComponentResult;
  1548.     {$IFC NOT GENERATINGCFM}
  1549.     INLINE $2F3C, $1A, $105, $7000, $A82A;
  1550.     {$ENDC}
  1551. FUNCTION HiliteTextSample(mh: MediaHandler; sampleTime: TimeValue; hiliteStart: INTEGER; hiliteEnd: INTEGER; VAR rgbHiliteColor: RGBColor): ComponentResult;
  1552.     {$IFC NOT GENERATINGCFM}
  1553.     INLINE $2F3C, $C, $106, $7000, $A82A;
  1554.     {$ENDC}
  1555.  
  1556. CONST
  1557.     dropShadowOffsetType        = 'drpo';
  1558.     dropShadowTranslucencyType    = 'drpt';
  1559.  
  1560.  
  1561. FUNCTION SetTextSampleData(mh: MediaHandler; data: UNIV Ptr; dataType: OSType): ComponentResult;
  1562.     {$IFC NOT GENERATINGCFM}
  1563.     INLINE $2F3C, $8, $107, $7000, $A82A;
  1564.     {$ENDC}
  1565. FUNCTION MovieSearchText(theMovie: Movie; text: Ptr; size: LONGINT; searchFlags: LONGINT; VAR searchTrack: Track; VAR searchTime: TimeValue; VAR searchOffset: LONGINT): OSErr;
  1566.     {$IFC NOT GENERATINGCFM}
  1567.     INLINE $303C, $207, $AAAA;
  1568.     {$ENDC}
  1569. PROCEDURE GetPosterBox(theMovie: Movie; VAR boxRect: Rect);
  1570.     {$IFC NOT GENERATINGCFM}
  1571.     INLINE $303C, $16F, $AAAA;
  1572.     {$ENDC}
  1573. PROCEDURE SetPosterBox(theMovie: Movie; {CONST}VAR boxRect: Rect);
  1574.     {$IFC NOT GENERATINGCFM}
  1575.     INLINE $303C, $170, $AAAA;
  1576.     {$ENDC}
  1577. FUNCTION GetMovieSegmentDisplayBoundsRgn(theMovie: Movie; time: TimeValue; duration: TimeValue): RgnHandle;
  1578.     {$IFC NOT GENERATINGCFM}
  1579.     INLINE $303C, $16C, $AAAA;
  1580.     {$ENDC}
  1581. FUNCTION GetTrackSegmentDisplayBoundsRgn(theTrack: Track; time: TimeValue; duration: TimeValue): RgnHandle;
  1582.     {$IFC NOT GENERATINGCFM}
  1583.     INLINE $303C, $16B, $AAAA;
  1584.     {$ENDC}
  1585. PROCEDURE SetMovieCoverProcs(theMovie: Movie; uncoverProc: MovieRgnCoverUPP; coverProc: MovieRgnCoverUPP; refcon: LONGINT);
  1586.     {$IFC NOT GENERATINGCFM}
  1587.     INLINE $303C, $179, $AAAA;
  1588.     {$ENDC}
  1589. FUNCTION GetMovieCoverProcs(theMovie: Movie; VAR uncoverProc: MovieRgnCoverUPP; VAR coverProc: MovieRgnCoverUPP; VAR refcon: LONGINT): OSErr;
  1590.     {$IFC NOT GENERATINGCFM}
  1591.     INLINE $303C, $1DD, $AAAA;
  1592.     {$ENDC}
  1593. FUNCTION GetTrackStatus(theTrack: Track): ComponentResult;
  1594.     {$IFC NOT GENERATINGCFM}
  1595.     INLINE $303C, $172, $AAAA;
  1596.     {$ENDC}
  1597. FUNCTION GetMovieStatus(theMovie: Movie; VAR firstProblemTrack: Track): ComponentResult;
  1598.     {$IFC NOT GENERATINGCFM}
  1599.     INLINE $303C, $173, $AAAA;
  1600.     {$ENDC}
  1601. {***
  1602.     Movie Controller support routines
  1603. ***}
  1604. FUNCTION NewMovieController(theMovie: Movie; {CONST}VAR movieRect: Rect; someFlags: LONGINT): ComponentInstance;
  1605.     {$IFC NOT GENERATINGCFM}
  1606.     INLINE $303C, $18A, $AAAA;
  1607.     {$ENDC}
  1608. PROCEDURE DisposeMovieController(mc: ComponentInstance);
  1609.     {$IFC NOT GENERATINGCFM}
  1610.     INLINE $303C, $18B, $AAAA;
  1611.     {$ENDC}
  1612. PROCEDURE ShowMovieInformation(theMovie: Movie; filterProc: ModalFilterUPP; refCon: LONGINT);
  1613.     {$IFC NOT GENERATINGCFM}
  1614.     INLINE $303C, $209, $AAAA;
  1615.     {$ENDC}
  1616. {****
  1617.     Scrap routines
  1618. ****}
  1619. FUNCTION PutMovieOnScrap(theMovie: Movie; movieScrapFlags: LONGINT): OSErr;
  1620.     {$IFC NOT GENERATINGCFM}
  1621.     INLINE $303C, $18C, $AAAA;
  1622.     {$ENDC}
  1623. FUNCTION NewMovieFromScrap(newMovieFlags: LONGINT): Movie;
  1624.     {$IFC NOT GENERATINGCFM}
  1625.     INLINE $303C, $18D, $AAAA;
  1626.     {$ENDC}
  1627. {****
  1628.     DataRef routines
  1629. ****}
  1630. FUNCTION GetMediaDataRef(theMedia: Media; index: INTEGER; VAR dataRef: Handle; VAR dataRefType: OSType; VAR dataRefAttributes: LONGINT): OSErr;
  1631.     {$IFC NOT GENERATINGCFM}
  1632.     INLINE $303C, $197, $AAAA;
  1633.     {$ENDC}
  1634. FUNCTION SetMediaDataRef(theMedia: Media; index: INTEGER; dataRef: Handle; dataRefType: OSType): OSErr;
  1635.     {$IFC NOT GENERATINGCFM}
  1636.     INLINE $303C, $1C9, $AAAA;
  1637.     {$ENDC}
  1638. FUNCTION SetMediaDataRefAttributes(theMedia: Media; index: INTEGER; dataRefAttributes: LONGINT): OSErr;
  1639.     {$IFC NOT GENERATINGCFM}
  1640.     INLINE $303C, $1CA, $AAAA;
  1641.     {$ENDC}
  1642. FUNCTION AddMediaDataRef(theMedia: Media; VAR index: INTEGER; dataRef: Handle; dataRefType: OSType): OSErr;
  1643.     {$IFC NOT GENERATINGCFM}
  1644.     INLINE $303C, $198, $AAAA;
  1645.     {$ENDC}
  1646. FUNCTION GetMediaDataRefCount(theMedia: Media; VAR count: INTEGER): OSErr;
  1647.     {$IFC NOT GENERATINGCFM}
  1648.     INLINE $303C, $199, $AAAA;
  1649.     {$ENDC}
  1650. {****
  1651.     Playback hint routines
  1652. ****}
  1653. PROCEDURE SetMoviePlayHints(theMovie: Movie; flags: LONGINT; flagsMask: LONGINT);
  1654.     {$IFC NOT GENERATINGCFM}
  1655.     INLINE $303C, $1A1, $AAAA;
  1656.     {$ENDC}
  1657. PROCEDURE SetMediaPlayHints(theMedia: Media; flags: LONGINT; flagsMask: LONGINT);
  1658.     {$IFC NOT GENERATINGCFM}
  1659.     INLINE $303C, $1A2, $AAAA;
  1660.     {$ENDC}
  1661. {****
  1662.     Load time track hints
  1663. ****}
  1664.  
  1665. CONST
  1666.     preloadAlways                = 1 * (2**(0));
  1667.     preloadOnlyIfEnabled        = 1 * (2**(1));
  1668.  
  1669.  
  1670. PROCEDURE SetTrackLoadSettings(theTrack: Track; preloadTime: TimeValue; preloadDuration: TimeValue; preloadFlags: LONGINT; defaultHints: LONGINT);
  1671.     {$IFC NOT GENERATINGCFM}
  1672.     INLINE $303C, $1E3, $AAAA;
  1673.     {$ENDC}
  1674. PROCEDURE GetTrackLoadSettings(theTrack: Track; VAR preloadTime: TimeValue; VAR preloadDuration: TimeValue; VAR preloadFlags: LONGINT; VAR defaultHints: LONGINT);
  1675.     {$IFC NOT GENERATINGCFM}
  1676.     INLINE $303C, $1E4, $AAAA;
  1677.     {$ENDC}
  1678.  
  1679. CONST
  1680.     MovieControllerComponentType = 'play';
  1681.  
  1682.     
  1683. TYPE
  1684.     MovieController = ComponentInstance;
  1685.  
  1686.  
  1687. CONST
  1688.     mcActionIdle                = 1;                            { no param}
  1689.     mcActionDraw                = 2;                            { param is WindowPtr}
  1690.     mcActionActivate            = 3;                            { no param}
  1691.     mcActionDeactivate            = 4;                            { no param}
  1692.     mcActionMouseDown            = 5;                            { param is pointer to EventRecord}
  1693.     mcActionKey                    = 6;                            { param is pointer to EventRecord}
  1694.     mcActionPlay                = 8;                            { param is Fixed, play rate}
  1695.     mcActionGoToTime            = 12;                            { param is TimeRecord}
  1696.     mcActionSetVolume            = 14;                            { param is a short}
  1697.     mcActionGetVolume            = 15;                            { param is pointer to a short}
  1698.     mcActionStep                = 18;                            { param is number of steps (short)}
  1699.     mcActionSetLooping            = 21;                            { param is Boolean}
  1700.     mcActionGetLooping            = 22;                            { param is pointer to a Boolean}
  1701.     mcActionSetLoopIsPalindrome    = 23;                            { param is Boolean}
  1702.     mcActionGetLoopIsPalindrome    = 24;                            { param is pointer to a Boolean}
  1703.     mcActionSetGrowBoxBounds    = 25;                            { param is a Rect}
  1704.     mcActionControllerSizeChanged = 26;                            { no param}
  1705.     mcActionSetSelectionBegin    = 29;                            { param is TimeRecord}
  1706.     mcActionSetSelectionDuration = 30;                            { param is TimeRecord, action only taken on set-duration}
  1707.     mcActionSetKeysEnabled        = 32;                            { param is Boolean}
  1708.     mcActionGetKeysEnabled        = 33;                            { param is pointer to Boolean}
  1709.     mcActionSetPlaySelection    = 34;                            { param is Boolean}
  1710.     mcActionGetPlaySelection    = 35;                            { param is pointer to Boolean}
  1711.     mcActionSetUseBadge            = 36;                            { param is Boolean}
  1712.     mcActionGetUseBadge            = 37;                            { param is pointer to Boolean}
  1713.     mcActionSetFlags            = 38;                            { param is long of flags}
  1714.     mcActionGetFlags            = 39;                            { param is pointer to a long of flags}
  1715.     mcActionSetPlayEveryFrame    = 40;                            { param is Boolean}
  1716.     mcActionGetPlayEveryFrame    = 41;                            { param is pointer to Boolean}
  1717.     mcActionGetPlayRate            = 42;                            { param is pointer to Fixed}
  1718.     mcActionShowBalloon            = 43;                            { param is a pointer to a boolean. set to false to stop balloon}
  1719.     mcActionBadgeClick            = 44;                            { param is pointer to Boolean. set to false to ignore click}
  1720.     mcActionMovieClick            = 45;                            { param is pointer to event record. change “what” to nullEvt to kill click}
  1721.     mcActionSuspend                = 46;                            { no param}
  1722.     mcActionResume                = 47;                            { no param}
  1723.     mcActionSetControllerKeysEnabled = 48;                        { param is Boolean}
  1724.     mcActionGetTimeSliderRect    = 49;                            { param is pointer to rect}
  1725.     mcActionMovieEdited            = 50;                            { no param}
  1726.     mcActionGetDragEnabled        = 51;                            { param is pointer to Boolean}
  1727.     mcActionSetDragEnabled        = 52;                            { param is Boolean}
  1728.  
  1729.     
  1730. TYPE
  1731.     mcAction = INTEGER;
  1732.  
  1733.  
  1734. CONST
  1735.     mcFlagSuppressMovieFrame    = 1 * (2**(0));
  1736.     mcFlagSuppressStepButtons    = 1 * (2**(1));
  1737.     mcFlagSuppressSpeakerButton    = 1 * (2**(2));
  1738.     mcFlagsUseWindowPalette        = 1 * (2**(3));
  1739.     mcFlagsDontInvalidate        = 1 * (2**(4));
  1740.  
  1741.     mcPositionDontInvalidate    = 1 * (2**(5));
  1742.  
  1743.     
  1744. TYPE
  1745.     mcFlags = LONGINT;
  1746.  
  1747.     MCActionFilterProcPtr = ProcPtr;  { FUNCTION MCActionFilter(mc: MovieController; VAR action: INTEGER; params: UNIV Ptr): BOOLEAN; }
  1748.     MCActionFilterWithRefConProcPtr = ProcPtr;  { FUNCTION MCActionFilterWithRefCon(mc: MovieController; action: INTEGER; params: UNIV Ptr; refCon: LONGINT): BOOLEAN; }
  1749.     MCActionFilterUPP = UniversalProcPtr;
  1750.     MCActionFilterWithRefConUPP = UniversalProcPtr;
  1751.  
  1752.  
  1753. CONST
  1754.     mcInfoUndoAvailable            = 1 * (2**(0));
  1755.     mcInfoCutAvailable            = 1 * (2**(1));
  1756.     mcInfoCopyAvailable            = 1 * (2**(2));
  1757.     mcInfoPasteAvailable        = 1 * (2**(3));
  1758.     mcInfoClearAvailable        = 1 * (2**(4));
  1759.     mcInfoHasSound                = 1 * (2**(5));
  1760.     mcInfoIsPlaying                = 1 * (2**(6));
  1761.     mcInfoIsLooping                = 1 * (2**(7));
  1762.     mcInfoIsInPalindrome        = 1 * (2**(8));
  1763.     mcInfoEditingEnabled        = 1 * (2**(9));
  1764.  
  1765. { menu item codes}
  1766.     mcMenuUndo                    = 1;
  1767.     mcMenuCut                    = 3;
  1768.     mcMenuCopy                    = 4;
  1769.     mcMenuPaste                    = 5;
  1770.     mcMenuClear                    = 6;
  1771.  
  1772. { target management }
  1773.  
  1774. FUNCTION MCSetMovie(mc: MovieController; theMovie: Movie; movieWindow: WindowPtr; where: Point): ComponentResult;
  1775.     {$IFC NOT GENERATINGCFM}
  1776.     INLINE $2F3C, $C, $2, $7000, $A82A;
  1777.     {$ENDC}
  1778. FUNCTION MCGetIndMovie(mc: MovieController; index: INTEGER): Movie;
  1779.     {$IFC NOT GENERATINGCFM}
  1780.     INLINE $2F3C, $2, $5, $7000, $A82A;
  1781.     {$ENDC}
  1782. FUNCTION MCRemoveMovie(mc: MovieController): ComponentResult;
  1783.     {$IFC NOT GENERATINGCFM}
  1784.     INLINE $2F3C, 0, $6, $7000, $A82A;
  1785.     {$ENDC}
  1786. { event handling etc. }
  1787. FUNCTION MCIsPlayerEvent(mc: MovieController; {CONST}VAR e: EventRecord): ComponentResult;
  1788.     {$IFC NOT GENERATINGCFM}
  1789.     INLINE $2F3C, $4, $7, $7000, $A82A;
  1790.     {$ENDC}
  1791. { obsolete. use MCSetActionFilterWithRefCon instead. }
  1792. FUNCTION MCSetActionFilter(mc: MovieController; blob: MCActionFilterUPP): ComponentResult;
  1793.     {$IFC NOT GENERATINGCFM}
  1794.     INLINE $2F3C, $4, $8, $7000, $A82A;
  1795.     {$ENDC}
  1796. {
  1797.     proc is of the form:
  1798.         Boolean userPlayerFilter(MovieController mc, short *action, void *params) =
  1799.     proc returns TRUE if it handles the action, FALSE if not
  1800.     action is passed as a VAR so that it could be changed by filter (ick)
  1801.     this is consistent with the current dialog manager stuff
  1802.     params is any potential parameters that go with the action <triple ick> 
  1803.         such as set playback rate to xxx.
  1804. }
  1805. FUNCTION MCDoAction(mc: MovieController; action: INTEGER; params: UNIV Ptr): ComponentResult;
  1806.     {$IFC NOT GENERATINGCFM}
  1807.     INLINE $2F3C, $6, $9, $7000, $A82A;
  1808.     {$ENDC}
  1809. { state type things }
  1810. FUNCTION MCSetControllerAttached(mc: MovieController; attach: BOOLEAN): ComponentResult;
  1811.     {$IFC NOT GENERATINGCFM}
  1812.     INLINE $2F3C, $2, $A, $7000, $A82A;
  1813.     {$ENDC}
  1814. FUNCTION MCIsControllerAttached(mc: MovieController): ComponentResult;
  1815.     {$IFC NOT GENERATINGCFM}
  1816.     INLINE $2F3C, 0, $B, $7000, $A82A;
  1817.     {$ENDC}
  1818. FUNCTION MCSetControllerPort(mc: MovieController; gp: CGrafPtr): ComponentResult;
  1819.     {$IFC NOT GENERATINGCFM}
  1820.     INLINE $2F3C, $4, $C, $7000, $A82A;
  1821.     {$ENDC}
  1822. FUNCTION MCGetControllerPort(mc: MovieController): CGrafPtr;
  1823.     {$IFC NOT GENERATINGCFM}
  1824.     INLINE $2F3C, 0, $D, $7000, $A82A;
  1825.     {$ENDC}
  1826. FUNCTION MCSetVisible(mc: MovieController; visible: BOOLEAN): ComponentResult;
  1827.     {$IFC NOT GENERATINGCFM}
  1828.     INLINE $2F3C, $2, $E, $7000, $A82A;
  1829.     {$ENDC}
  1830. FUNCTION MCGetVisible(mc: MovieController): ComponentResult;
  1831.     {$IFC NOT GENERATINGCFM}
  1832.     INLINE $2F3C, 0, $F, $7000, $A82A;
  1833.     {$ENDC}
  1834. FUNCTION MCGetControllerBoundsRect(mc: MovieController; VAR bounds: Rect): ComponentResult;
  1835.     {$IFC NOT GENERATINGCFM}
  1836.     INLINE $2F3C, $4, $10, $7000, $A82A;
  1837.     {$ENDC}
  1838. FUNCTION MCSetControllerBoundsRect(mc: MovieController; {CONST}VAR bounds: Rect): ComponentResult;
  1839.     {$IFC NOT GENERATINGCFM}
  1840.     INLINE $2F3C, $4, $11, $7000, $A82A;
  1841.     {$ENDC}
  1842. FUNCTION MCGetControllerBoundsRgn(mc: MovieController): RgnHandle;
  1843.     {$IFC NOT GENERATINGCFM}
  1844.     INLINE $2F3C, 0, $12, $7000, $A82A;
  1845.     {$ENDC}
  1846. FUNCTION MCGetWindowRgn(mc: MovieController; w: WindowPtr): RgnHandle;
  1847.     {$IFC NOT GENERATINGCFM}
  1848.     INLINE $2F3C, $4, $13, $7000, $A82A;
  1849.     {$ENDC}
  1850. { other stuff }
  1851. FUNCTION MCMovieChanged(mc: MovieController; m: Movie): ComponentResult;
  1852.     {$IFC NOT GENERATINGCFM}
  1853.     INLINE $2F3C, $4, $14, $7000, $A82A;
  1854.     {$ENDC}
  1855. {
  1856.     called when the app has changed thing about the movie (like bounding rect) or rate. So that we
  1857.         can update our graphical (and internal) state accordingly.
  1858. }
  1859. FUNCTION MCSetDuration(mc: MovieController; duration: TimeValue): ComponentResult;
  1860.     {$IFC NOT GENERATINGCFM}
  1861.     INLINE $2F3C, $4, $15, $7000, $A82A;
  1862.     {$ENDC}
  1863. {
  1864.     duration to use for time slider -- will be reset next time MCMovieChanged is called
  1865.         or MCSetMovie is called
  1866. }
  1867. FUNCTION MCGetCurrentTime(mc: MovieController; VAR scale: TimeScale): TimeValue;
  1868.     {$IFC NOT GENERATINGCFM}
  1869.     INLINE $2F3C, $4, $16, $7000, $A82A;
  1870.     {$ENDC}
  1871. {
  1872.     returns the time value and the time scale it is on. if there are no movies, the
  1873.         time scale is passed back as 0. scale is an optional parameter
  1874.  
  1875. }
  1876. FUNCTION MCNewAttachedController(mc: MovieController; theMovie: Movie; w: WindowPtr; where: Point): ComponentResult;
  1877.     {$IFC NOT GENERATINGCFM}
  1878.     INLINE $2F3C, $C, $17, $7000, $A82A;
  1879.     {$ENDC}
  1880. {
  1881.     makes m the only movie attached to the controller. makes the controller visible.
  1882.     the window and where parameters are passed a long to MCSetMovie and behave as
  1883.     described there
  1884. }
  1885. FUNCTION MCDraw(mc: MovieController; w: WindowPtr): ComponentResult;
  1886.     {$IFC NOT GENERATINGCFM}
  1887.     INLINE $2F3C, $4, $18, $7000, $A82A;
  1888.     {$ENDC}
  1889. FUNCTION MCActivate(mc: MovieController; w: WindowPtr; activate: BOOLEAN): ComponentResult;
  1890.     {$IFC NOT GENERATINGCFM}
  1891.     INLINE $2F3C, $6, $19, $7000, $A82A;
  1892.     {$ENDC}
  1893. FUNCTION MCIdle(mc: MovieController): ComponentResult;
  1894.     {$IFC NOT GENERATINGCFM}
  1895.     INLINE $2F3C, 0, $1A, $7000, $A82A;
  1896.     {$ENDC}
  1897. FUNCTION MCKey(mc: MovieController; key: ByteParameter; modifiers: LONGINT): ComponentResult;
  1898.     {$IFC NOT GENERATINGCFM}
  1899.     INLINE $2F3C, $6, $1B, $7000, $A82A;
  1900.     {$ENDC}
  1901. FUNCTION MCClick(mc: MovieController; w: WindowPtr; where: Point; when: LONGINT; modifiers: LONGINT): ComponentResult;
  1902.     {$IFC NOT GENERATINGCFM}
  1903.     INLINE $2F3C, $10, $1C, $7000, $A82A;
  1904.     {$ENDC}
  1905. {
  1906.     calls for editing
  1907. }
  1908. FUNCTION MCEnableEditing(mc: MovieController; enabled: BOOLEAN): ComponentResult;
  1909.     {$IFC NOT GENERATINGCFM}
  1910.     INLINE $2F3C, $2, $1D, $7000, $A82A;
  1911.     {$ENDC}
  1912. FUNCTION MCIsEditingEnabled(mc: MovieController): LONGINT;
  1913.     {$IFC NOT GENERATINGCFM}
  1914.     INLINE $2F3C, 0, $1E, $7000, $A82A;
  1915.     {$ENDC}
  1916. FUNCTION MCCopy(mc: MovieController): Movie;
  1917.     {$IFC NOT GENERATINGCFM}
  1918.     INLINE $2F3C, 0, $1F, $7000, $A82A;
  1919.     {$ENDC}
  1920. FUNCTION MCCut(mc: MovieController): Movie;
  1921.     {$IFC NOT GENERATINGCFM}
  1922.     INLINE $2F3C, 0, $20, $7000, $A82A;
  1923.     {$ENDC}
  1924. FUNCTION MCPaste(mc: MovieController; srcMovie: Movie): ComponentResult;
  1925.     {$IFC NOT GENERATINGCFM}
  1926.     INLINE $2F3C, $4, $21, $7000, $A82A;
  1927.     {$ENDC}
  1928. FUNCTION MCClear(mc: MovieController): ComponentResult;
  1929.     {$IFC NOT GENERATINGCFM}
  1930.     INLINE $2F3C, 0, $22, $7000, $A82A;
  1931.     {$ENDC}
  1932. FUNCTION MCUndo(mc: MovieController): ComponentResult;
  1933.     {$IFC NOT GENERATINGCFM}
  1934.     INLINE $2F3C, 0, $23, $7000, $A82A;
  1935.     {$ENDC}
  1936. {
  1937.  *    somewhat special stuff
  1938.  }
  1939. FUNCTION MCPositionController(mc: MovieController; {CONST}VAR movieRect: Rect; {CONST}VAR controllerRect: Rect; someFlags: LONGINT): ComponentResult;
  1940.     {$IFC NOT GENERATINGCFM}
  1941.     INLINE $2F3C, $C, $24, $7000, $A82A;
  1942.     {$ENDC}
  1943. FUNCTION MCGetControllerInfo(mc: MovieController; VAR someFlags: LONGINT): ComponentResult;
  1944.     {$IFC NOT GENERATINGCFM}
  1945.     INLINE $2F3C, $4, $25, $7000, $A82A;
  1946.     {$ENDC}
  1947. FUNCTION MCSetClip(mc: MovieController; theClip: RgnHandle; movieClip: RgnHandle): ComponentResult;
  1948.     {$IFC NOT GENERATINGCFM}
  1949.     INLINE $2F3C, $8, $28, $7000, $A82A;
  1950.     {$ENDC}
  1951. FUNCTION MCGetClip(mc: MovieController; VAR theClip: RgnHandle; VAR movieClip: RgnHandle): ComponentResult;
  1952.     {$IFC NOT GENERATINGCFM}
  1953.     INLINE $2F3C, $8, $29, $7000, $A82A;
  1954.     {$ENDC}
  1955. FUNCTION MCDrawBadge(mc: MovieController; movieRgn: RgnHandle; VAR badgeRgn: RgnHandle): ComponentResult;
  1956.     {$IFC NOT GENERATINGCFM}
  1957.     INLINE $2F3C, $8, $2A, $7000, $A82A;
  1958.     {$ENDC}
  1959. FUNCTION MCSetUpEditMenu(mc: MovieController; modifiers: LONGINT; mh: MenuHandle): ComponentResult;
  1960.     {$IFC NOT GENERATINGCFM}
  1961.     INLINE $2F3C, $8, $2B, $7000, $A82A;
  1962.     {$ENDC}
  1963. FUNCTION MCGetMenuString(mc: MovieController; modifiers: LONGINT; item: INTEGER; VAR aString: Str255): ComponentResult;
  1964.     {$IFC NOT GENERATINGCFM}
  1965.     INLINE $2F3C, $A, $2C, $7000, $A82A;
  1966.     {$ENDC}
  1967. FUNCTION MCSetActionFilterWithRefCon(mc: MovieController; blob: MCActionFilterWithRefConUPP; refCon: LONGINT): ComponentResult;
  1968.     {$IFC NOT GENERATINGCFM}
  1969.     INLINE $2F3C, $8, $2D, $7000, $A82A;
  1970.     {$ENDC}
  1971.  
  1972. CONST
  1973.     kMCSetMovieSelect            = $2;
  1974.     kMCGetIndMovieSelect        = $5;
  1975.     kMCRemoveMovieSelect        = $6;
  1976.     kMCIsPlayerEventSelect        = $7;
  1977.     kMCSetActionFilterSelect    = $8;
  1978.     kMCDoActionSelect            = $9;
  1979.     kMCSetControllerAttachedSelect = $A;
  1980.     kMCIsControllerAttachedSelect = $B;
  1981.     kMCSetControllerPortSelect    = $C;
  1982.     kMCGetControllerPortSelect    = $D;
  1983.     kMCSetVisibleSelect            = $E;
  1984.     kMCGetVisibleSelect            = $F;
  1985.     kMCGetControllerBoundsRectSelect = $10;
  1986.     kMCSetControllerBoundsRectSelect = $11;
  1987.     kMCGetControllerBoundsRgnSelect = $12;
  1988.     kMCGetWindowRgnSelect        = $13;
  1989.     kMCMovieChangedSelect        = $14;
  1990.     kMCSetDurationSelect        = $15;
  1991.     kMCGetCurrentTimeSelect        = $16;
  1992.     kMCNewAttachedControllerSelect = $17;
  1993.     kMCDrawSelect                = $18;
  1994.     kMCActivateSelect            = $19;
  1995.     kMCIdleSelect                = $1A;
  1996.     kMCKeySelect                = $1B;
  1997.     kMCClickSelect                = $1C;
  1998.     kMCEnableEditingSelect        = $1D;
  1999.     kMCIsEditingEnabledSelect    = $1E;
  2000.     kMCCopySelect                = $1F;
  2001.     kMCCutSelect                = $20;
  2002.     kMCPasteSelect                = $21;
  2003.     kMCClearSelect                = $22;
  2004.     kMCUndoSelect                = $23;
  2005.     kMCPositionControllerSelect    = $24;
  2006.     kMCGetControllerInfoSelect    = $25;
  2007.     kMCSetClipSelect            = $28;
  2008.     kMCGetClipSelect            = $29;
  2009.     kMCDrawBadgeSelect            = $2A;
  2010.     kMCSetUpEditMenuSelect        = $2B;
  2011.     kMCGetMenuStringSelect        = $2C;
  2012.     kMCSetActionFilterWithRefConSelect = $2D;
  2013.  
  2014. {***************************************
  2015. *                                        *
  2016. *          T  I  M  E  B  A  S  E            *
  2017. *                                        *
  2018. ***************************************}
  2019.  
  2020. FUNCTION NewTimeBase: TimeBase;
  2021.     {$IFC NOT GENERATINGCFM}
  2022.     INLINE $303C, $A5, $AAAA;
  2023.     {$ENDC}
  2024. PROCEDURE DisposeTimeBase(tb: TimeBase);
  2025.     {$IFC NOT GENERATINGCFM}
  2026.     INLINE $303C, $B6, $AAAA;
  2027.     {$ENDC}
  2028. FUNCTION GetTimeBaseTime(tb: TimeBase; s: TimeScale; VAR tr: TimeRecord): TimeValue;
  2029.     {$IFC NOT GENERATINGCFM}
  2030.     INLINE $303C, $A6, $AAAA;
  2031.     {$ENDC}
  2032. PROCEDURE SetTimeBaseTime(tb: TimeBase; {CONST}VAR tr: TimeRecord);
  2033.     {$IFC NOT GENERATINGCFM}
  2034.     INLINE $303C, $A7, $AAAA;
  2035.     {$ENDC}
  2036. PROCEDURE SetTimeBaseValue(tb: TimeBase; t: TimeValue; s: TimeScale);
  2037.     {$IFC NOT GENERATINGCFM}
  2038.     INLINE $303C, $A8, $AAAA;
  2039.     {$ENDC}
  2040. FUNCTION GetTimeBaseRate(tb: TimeBase): Fixed;
  2041.     {$IFC NOT GENERATINGCFM}
  2042.     INLINE $303C, $A9, $AAAA;
  2043.     {$ENDC}
  2044. PROCEDURE SetTimeBaseRate(tb: TimeBase; r: Fixed);
  2045.     {$IFC NOT GENERATINGCFM}
  2046.     INLINE $303C, $AA, $AAAA;
  2047.     {$ENDC}
  2048. FUNCTION GetTimeBaseStartTime(tb: TimeBase; s: TimeScale; VAR tr: TimeRecord): TimeValue;
  2049.     {$IFC NOT GENERATINGCFM}
  2050.     INLINE $303C, $AB, $AAAA;
  2051.     {$ENDC}
  2052. PROCEDURE SetTimeBaseStartTime(tb: TimeBase; {CONST}VAR tr: TimeRecord);
  2053.     {$IFC NOT GENERATINGCFM}
  2054.     INLINE $303C, $AC, $AAAA;
  2055.     {$ENDC}
  2056. FUNCTION GetTimeBaseStopTime(tb: TimeBase; s: TimeScale; VAR tr: TimeRecord): TimeValue;
  2057.     {$IFC NOT GENERATINGCFM}
  2058.     INLINE $303C, $AD, $AAAA;
  2059.     {$ENDC}
  2060. PROCEDURE SetTimeBaseStopTime(tb: TimeBase; {CONST}VAR tr: TimeRecord);
  2061.     {$IFC NOT GENERATINGCFM}
  2062.     INLINE $303C, $AE, $AAAA;
  2063.     {$ENDC}
  2064. FUNCTION GetTimeBaseFlags(tb: TimeBase): LONGINT;
  2065.     {$IFC NOT GENERATINGCFM}
  2066.     INLINE $303C, $B1, $AAAA;
  2067.     {$ENDC}
  2068. PROCEDURE SetTimeBaseFlags(tb: TimeBase; timeBaseFlags: LONGINT);
  2069.     {$IFC NOT GENERATINGCFM}
  2070.     INLINE $303C, $B2, $AAAA;
  2071.     {$ENDC}
  2072. PROCEDURE SetTimeBaseMasterTimeBase(slave: TimeBase; master: TimeBase; {CONST}VAR slaveZero: TimeRecord);
  2073.     {$IFC NOT GENERATINGCFM}
  2074.     INLINE $303C, $B4, $AAAA;
  2075.     {$ENDC}
  2076. FUNCTION GetTimeBaseMasterTimeBase(tb: TimeBase): TimeBase;
  2077.     {$IFC NOT GENERATINGCFM}
  2078.     INLINE $303C, $AF, $AAAA;
  2079.     {$ENDC}
  2080. PROCEDURE SetTimeBaseMasterClock(slave: TimeBase; clockMeister: Component; {CONST}VAR slaveZero: TimeRecord);
  2081.     {$IFC NOT GENERATINGCFM}
  2082.     INLINE $303C, $B3, $AAAA;
  2083.     {$ENDC}
  2084. FUNCTION GetTimeBaseMasterClock(tb: TimeBase): ComponentInstance;
  2085.     {$IFC NOT GENERATINGCFM}
  2086.     INLINE $303C, $B0, $AAAA;
  2087.     {$ENDC}
  2088. PROCEDURE ConvertTime(VAR inout: TimeRecord; newBase: TimeBase);
  2089.     {$IFC NOT GENERATINGCFM}
  2090.     INLINE $303C, $B5, $AAAA;
  2091.     {$ENDC}
  2092. PROCEDURE ConvertTimeScale(VAR inout: TimeRecord; newScale: TimeScale);
  2093.     {$IFC NOT GENERATINGCFM}
  2094.     INLINE $303C, $B7, $AAAA;
  2095.     {$ENDC}
  2096. PROCEDURE AddTime(VAR dst: TimeRecord; {CONST}VAR src: TimeRecord);
  2097.     {$IFC NOT GENERATINGCFM}
  2098.     INLINE $303C, $10C, $AAAA;
  2099.     {$ENDC}
  2100. PROCEDURE SubtractTime(VAR dst: TimeRecord; {CONST}VAR src: TimeRecord);
  2101.     {$IFC NOT GENERATINGCFM}
  2102.     INLINE $303C, $10D, $AAAA;
  2103.     {$ENDC}
  2104. FUNCTION GetTimeBaseStatus(tb: TimeBase; VAR unpinnedTime: TimeRecord): LONGINT;
  2105.     {$IFC NOT GENERATINGCFM}
  2106.     INLINE $303C, $10B, $AAAA;
  2107.     {$ENDC}
  2108. PROCEDURE SetTimeBaseZero(tb: TimeBase; VAR zero: TimeRecord);
  2109.     {$IFC NOT GENERATINGCFM}
  2110.     INLINE $303C, $128, $AAAA;
  2111.     {$ENDC}
  2112. FUNCTION GetTimeBaseEffectiveRate(tb: TimeBase): Fixed;
  2113.     {$IFC NOT GENERATINGCFM}
  2114.     INLINE $303C, $124, $AAAA;
  2115.     {$ENDC}
  2116. {***************************************
  2117. *                                        *
  2118. *          C  A  L  L  B  A  C  K             *
  2119. *                                        *
  2120. ***************************************}
  2121. FUNCTION NewCallBack(tb: TimeBase; cbType: INTEGER): QTCallBack;
  2122.     {$IFC NOT GENERATINGCFM}
  2123.     INLINE $303C, $EB, $AAAA;
  2124.     {$ENDC}
  2125. PROCEDURE DisposeCallBack(cb: QTCallBack);
  2126.     {$IFC NOT GENERATINGCFM}
  2127.     INLINE $303C, $EC, $AAAA;
  2128.     {$ENDC}
  2129. FUNCTION GetCallBackType(cb: QTCallBack): INTEGER;
  2130.     {$IFC NOT GENERATINGCFM}
  2131.     INLINE $303C, $ED, $AAAA;
  2132.     {$ENDC}
  2133. FUNCTION GetCallBackTimeBase(cb: QTCallBack): TimeBase;
  2134.     {$IFC NOT GENERATINGCFM}
  2135.     INLINE $303C, $EE, $AAAA;
  2136.     {$ENDC}
  2137. FUNCTION CallMeWhen(cb: QTCallBack; callBackProc: QTCallBackUPP; refCon: LONGINT; param1: LONGINT; param2: LONGINT; param3: LONGINT): OSErr;
  2138.     {$IFC NOT GENERATINGCFM}
  2139.     INLINE $303C, $B8, $AAAA;
  2140.     {$ENDC}
  2141. PROCEDURE CancelCallBack(cb: QTCallBack);
  2142.     {$IFC NOT GENERATINGCFM}
  2143.     INLINE $303C, $B9, $AAAA;
  2144.     {$ENDC}
  2145. {***************************************
  2146. *                                        *
  2147. *          C L O C K   C A L L B A C K      *
  2148. *                S U P P O R T              *
  2149. *                                        *
  2150. ***************************************}
  2151. FUNCTION AddCallBackToTimeBase(cb: QTCallBack): OSErr;
  2152.     {$IFC NOT GENERATINGCFM}
  2153.     INLINE $303C, $129, $AAAA;
  2154.     {$ENDC}
  2155. FUNCTION RemoveCallBackFromTimeBase(cb: QTCallBack): OSErr;
  2156.     {$IFC NOT GENERATINGCFM}
  2157.     INLINE $303C, $12A, $AAAA;
  2158.     {$ENDC}
  2159. FUNCTION GetFirstCallBack(tb: TimeBase): QTCallBack;
  2160.     {$IFC NOT GENERATINGCFM}
  2161.     INLINE $303C, $12B, $AAAA;
  2162.     {$ENDC}
  2163. FUNCTION GetNextCallBack(cb: QTCallBack): QTCallBack;
  2164.     {$IFC NOT GENERATINGCFM}
  2165.     INLINE $303C, $12C, $AAAA;
  2166.     {$ENDC}
  2167. PROCEDURE ExecuteCallBack(cb: QTCallBack);
  2168.     {$IFC NOT GENERATINGCFM}
  2169.     INLINE $303C, $12D, $AAAA;
  2170.     {$ENDC}
  2171. {***************************************
  2172. *                                        *
  2173. *          S Y N C    T A S K S              *
  2174. *                S U P P O R T              *
  2175. *                                        *
  2176. ***************************************}
  2177. FUNCTION QueueSyncTask(task: QTSyncTaskPtr): OSErr;
  2178.     {$IFC NOT GENERATINGCFM}
  2179.     INLINE $303C, $203, $AAAA;
  2180.     {$ENDC}
  2181. FUNCTION DequeueSyncTask(qElem: QTSyncTaskPtr): OSErr;
  2182.     {$IFC NOT GENERATINGCFM}
  2183.     INLINE $303C, $204, $AAAA;
  2184.     {$ENDC}
  2185. { UPP call backs }
  2186.  
  2187. CONST
  2188.     uppMovieRgnCoverProcInfo = $00000FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  2189.     uppMovieProgressProcInfo = $0000FAE0; { FUNCTION (4 byte param, 2 byte param, 2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  2190.     uppMovieDrawingCompleteProcInfo = $000003E0; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }
  2191.     uppTrackTransferProcInfo = $000003E0; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }
  2192.     uppGetMovieProcInfo = $00003FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  2193.     uppMoviePreviewCallOutProcInfo = $000000D0; { FUNCTION (4 byte param): 1 byte result; }
  2194.     uppMoviesErrorProcInfo = $00000380; { PROCEDURE (2 byte param, 4 byte param); }
  2195.     uppTextMediaProcInfo = $00003FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  2196.     uppQTCallBackProcInfo = $000003C0; { PROCEDURE (4 byte param, 4 byte param); }
  2197.     uppQTSyncTaskProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  2198.     uppMCActionFilterProcInfo = $00000FD0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 1 byte result; }
  2199.     uppMCActionFilterWithRefConProcInfo = $00003ED0; { FUNCTION (4 byte param, 2 byte param, 4 byte param, 4 byte param): 1 byte result; }
  2200.  
  2201. FUNCTION NewMovieRgnCoverProc(userRoutine: MovieRgnCoverProcPtr): MovieRgnCoverUPP;
  2202.     {$IFC NOT GENERATINGCFM }
  2203.     INLINE $2E9F;
  2204.     {$ENDC}
  2205.  
  2206. FUNCTION NewMovieProgressProc(userRoutine: MovieProgressProcPtr): MovieProgressUPP;
  2207.     {$IFC NOT GENERATINGCFM }
  2208.     INLINE $2E9F;
  2209.     {$ENDC}
  2210.  
  2211. FUNCTION NewMovieDrawingCompleteProc(userRoutine: MovieDrawingCompleteProcPtr): MovieDrawingCompleteUPP;
  2212.     {$IFC NOT GENERATINGCFM }
  2213.     INLINE $2E9F;
  2214.     {$ENDC}
  2215.  
  2216. FUNCTION NewTrackTransferProc(userRoutine: TrackTransferProcPtr): TrackTransferUPP;
  2217.     {$IFC NOT GENERATINGCFM }
  2218.     INLINE $2E9F;
  2219.     {$ENDC}
  2220.  
  2221. FUNCTION NewGetMovieProc(userRoutine: GetMovieProcPtr): GetMovieUPP;
  2222.     {$IFC NOT GENERATINGCFM }
  2223.     INLINE $2E9F;
  2224.     {$ENDC}
  2225.  
  2226. FUNCTION NewMoviePreviewCallOutProc(userRoutine: MoviePreviewCallOutProcPtr): MoviePreviewCallOutUPP;
  2227.     {$IFC NOT GENERATINGCFM }
  2228.     INLINE $2E9F;
  2229.     {$ENDC}
  2230.  
  2231. FUNCTION NewMoviesErrorProc(userRoutine: MoviesErrorProcPtr): MoviesErrorUPP;
  2232.     {$IFC NOT GENERATINGCFM }
  2233.     INLINE $2E9F;
  2234.     {$ENDC}
  2235.  
  2236. FUNCTION NewTextMediaProc(userRoutine: TextMediaProcPtr): TextMediaUPP;
  2237.     {$IFC NOT GENERATINGCFM }
  2238.     INLINE $2E9F;
  2239.     {$ENDC}
  2240.  
  2241. FUNCTION NewQTCallBackProc(userRoutine: QTCallBackProcPtr): QTCallBackUPP;
  2242.     {$IFC NOT GENERATINGCFM }
  2243.     INLINE $2E9F;
  2244.     {$ENDC}
  2245.  
  2246. FUNCTION NewQTSyncTaskProc(userRoutine: QTSyncTaskProcPtr): QTSyncTaskUPP;
  2247.     {$IFC NOT GENERATINGCFM }
  2248.     INLINE $2E9F;
  2249.     {$ENDC}
  2250.  
  2251. FUNCTION NewMCActionFilterProc(userRoutine: MCActionFilterProcPtr): MCActionFilterUPP;
  2252.     {$IFC NOT GENERATINGCFM }
  2253.     INLINE $2E9F;
  2254.     {$ENDC}
  2255.  
  2256. FUNCTION NewMCActionFilterWithRefConProc(userRoutine: MCActionFilterWithRefConProcPtr): MCActionFilterWithRefConUPP;
  2257.     {$IFC NOT GENERATINGCFM }
  2258.     INLINE $2E9F;
  2259.     {$ENDC}
  2260.  
  2261. FUNCTION CallMovieRgnCoverProc(theMovie: Movie; changedRgn: RgnHandle; refcon: LONGINT; userRoutine: MovieRgnCoverUPP): OSErr;
  2262.     {$IFC NOT GENERATINGCFM}
  2263.     INLINE $205F, $4E90;
  2264.     {$ENDC}
  2265.  
  2266. FUNCTION CallMovieProgressProc(theMovie: Movie; message: INTEGER; whatOperation: INTEGER; percentDone: Fixed; refcon: LONGINT; userRoutine: MovieProgressUPP): OSErr;
  2267.     {$IFC NOT GENERATINGCFM}
  2268.     INLINE $205F, $4E90;
  2269.     {$ENDC}
  2270.  
  2271. FUNCTION CallMovieDrawingCompleteProc(theMovie: Movie; refCon: LONGINT; userRoutine: MovieDrawingCompleteUPP): OSErr;
  2272.     {$IFC NOT GENERATINGCFM}
  2273.     INLINE $205F, $4E90;
  2274.     {$ENDC}
  2275.  
  2276. FUNCTION CallTrackTransferProc(t: Track; refCon: LONGINT; userRoutine: TrackTransferUPP): OSErr;
  2277.     {$IFC NOT GENERATINGCFM}
  2278.     INLINE $205F, $4E90;
  2279.     {$ENDC}
  2280.  
  2281. FUNCTION CallGetMovieProc(offset: LONGINT; size: LONGINT; dataPtr: UNIV Ptr; refCon: UNIV Ptr; userRoutine: GetMovieUPP): OSErr;
  2282.     {$IFC NOT GENERATINGCFM}
  2283.     INLINE $205F, $4E90;
  2284.     {$ENDC}
  2285.  
  2286. FUNCTION CallMoviePreviewCallOutProc(refcon: LONGINT; userRoutine: MoviePreviewCallOutUPP): BOOLEAN;
  2287.     {$IFC NOT GENERATINGCFM}
  2288.     INLINE $205F, $4E90;
  2289.     {$ENDC}
  2290.  
  2291. PROCEDURE CallMoviesErrorProc(theErr: OSErr; refcon: LONGINT; userRoutine: MoviesErrorUPP);
  2292.     {$IFC NOT GENERATINGCFM}
  2293.     INLINE $205F, $4E90;
  2294.     {$ENDC}
  2295.  
  2296. FUNCTION CallTextMediaProc(theText: Handle; theMovie: Movie; VAR displayFlag: INTEGER; refcon: LONGINT; userRoutine: TextMediaUPP): OSErr;
  2297.     {$IFC NOT GENERATINGCFM}
  2298.     INLINE $205F, $4E90;
  2299.     {$ENDC}
  2300.  
  2301. PROCEDURE CallQTCallBackProc(cb: QTCallBack; refCon: LONGINT; userRoutine: QTCallBackUPP);
  2302.     {$IFC NOT GENERATINGCFM}
  2303.     INLINE $205F, $4E90;
  2304.     {$ENDC}
  2305.  
  2306. PROCEDURE CallQTSyncTaskProc(task: UNIV Ptr; userRoutine: QTSyncTaskUPP);
  2307.     {$IFC NOT GENERATINGCFM}
  2308.     INLINE $205F, $4E90;
  2309.     {$ENDC}
  2310.  
  2311. FUNCTION CallMCActionFilterProc(mc: MovieController; VAR action: INTEGER; params: UNIV Ptr; userRoutine: MCActionFilterUPP): BOOLEAN;
  2312.     {$IFC NOT GENERATINGCFM}
  2313.     INLINE $205F, $4E90;
  2314.     {$ENDC}
  2315.  
  2316. FUNCTION CallMCActionFilterWithRefConProc(mc: MovieController; action: INTEGER; params: UNIV Ptr; refCon: LONGINT; userRoutine: MCActionFilterWithRefConUPP): BOOLEAN;
  2317.     {$IFC NOT GENERATINGCFM}
  2318.     INLINE $205F, $4E90;
  2319.     {$ENDC}
  2320.  
  2321. {$ALIGN RESET}
  2322. {$POP}
  2323.  
  2324. {$SETC UsingIncludes := MoviesIncludes}
  2325.  
  2326. {$ENDC} {__MOVIES__}
  2327.  
  2328. {$IFC NOT UsingIncludes}
  2329.  END.
  2330. {$ENDC}
  2331.